home *** CD-ROM | disk | FTP | other *** search
/ SGI Freeware 1999 August / SGI Freeware 1999 August.iso / dist / samba.idb / usr / samba / src / source / util.c.z / util.c
Encoding:
C/C++ Source or Header  |  1998-10-28  |  128.9 KB  |  5,280 lines

  1. /* 
  2.    Unix SMB/Netbios implementation.
  3.    Version 1.9.
  4.    Samba utility functions
  5.    Copyright (C) Andrew Tridgell 1992-1998
  6.    
  7.    This program is free software; you can redistribute it and/or modify
  8.    it under the terms of the GNU General Public License as published by
  9.    the Free Software Foundation; either version 2 of the License, or
  10.    (at your option) any later version.
  11.    
  12.    This program is distributed in the hope that it will be useful,
  13.    but WITHOUT ANY WARRANTY; without even the implied warranty of
  14.    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15.    GNU General Public License for more details.
  16.    
  17.    You should have received a copy of the GNU General Public License
  18.    along with this program; if not, write to the Free Software
  19.    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  20. */
  21.  
  22. #include "includes.h"
  23.  
  24. #if (defined(NETGROUP) && defined (AUTOMOUNT))
  25. #ifdef NISPLUS
  26. #include <rpcsvc/nis.h>
  27. #else
  28. #include "rpcsvc/ypclnt.h"
  29. #endif
  30. #endif
  31.  
  32. pstring scope = "";
  33.  
  34. int DEBUGLEVEL = 1;
  35.  
  36. BOOL passive = False;
  37.  
  38. int Protocol = PROTOCOL_COREPLUS;
  39.  
  40. /* a default finfo structure to ensure all fields are sensible */
  41. file_info def_finfo = {-1,0,0,0,0,0,0,""};
  42.  
  43. /* these are some file handles where debug info will be stored */
  44. FILE *dbf = NULL;
  45.  
  46. /* the client file descriptor */
  47. int Client = -1;
  48.  
  49. /* the last IP received from */
  50. struct in_addr lastip;
  51.  
  52. /* the last port received from */
  53. int lastport=0;
  54.  
  55. /* this is used by the chaining code */
  56. int chain_size = 0;
  57.  
  58. int trans_num = 0;
  59.  
  60. /*
  61.    case handling on filenames 
  62. */
  63. int case_default = CASE_LOWER;
  64.  
  65. pstring debugf = "";
  66. int syslog_level;
  67.  
  68. /* the following control case operations - they are put here so the
  69.    client can link easily */
  70. BOOL case_sensitive;
  71. BOOL case_preserve;
  72. BOOL use_mangled_map = False;
  73. BOOL short_case_preserve;
  74. BOOL case_mangle;
  75.  
  76. fstring remote_machine="";
  77. fstring local_machine="";
  78. fstring remote_arch="UNKNOWN";
  79. static enum remote_arch_types ra_type = RA_UNKNOWN;
  80. fstring remote_proto="UNKNOWN";
  81. pstring myhostname="";
  82. pstring user_socket_options="";   
  83.  
  84. pstring sesssetup_user="";
  85. pstring samlogon_user="";
  86.  
  87. BOOL sam_logon_in_ssb = False;
  88.  
  89. pstring myname = "";
  90. fstring myworkgroup = "";
  91. char **my_netbios_names;
  92.  
  93. int smb_read_error = 0;
  94.  
  95. static BOOL stdout_logging = False;
  96.  
  97. static char *filename_dos(char *path,char *buf);
  98.  
  99. #if defined(SIGUSR2)
  100. /**************************************************************************** **
  101.  catch a sigusr2 - decrease the debug log level.
  102.  **************************************************************************** */
  103. int sig_usr2(void)
  104. {  
  105.   BlockSignals( True, SIGUSR2);
  106.  
  107.   DEBUGLEVEL--; 
  108.    
  109.   if(DEBUGLEVEL < 0) 
  110.     DEBUGLEVEL = 0; 
  111.  
  112.   DEBUG( 0, ( "Got SIGUSR2 set debug level to %d.\n", DEBUGLEVEL ) );
  113.    
  114.   BlockSignals( False, SIGUSR2);
  115. #ifndef DONT_REINSTALL_SIG
  116.   signal(SIGUSR2, SIGNAL_CAST sig_usr2);
  117. #endif 
  118.   return(0);
  119. }  
  120. #endif /* SIGUSR1 */
  121.    
  122. #if defined(SIGUSR1)
  123. /**************************************************************************** **
  124.  catch a sigusr1 - increase the debug log level. 
  125.  **************************************************************************** */
  126. int sig_usr1(void)
  127. {
  128.   BlockSignals( True, SIGUSR1);
  129.  
  130.   DEBUGLEVEL++;
  131.  
  132.   if(DEBUGLEVEL > 10)
  133.     DEBUGLEVEL = 10;
  134.  
  135.   DEBUG( 0, ( "Got SIGUSR1 set debug level to %d.\n", DEBUGLEVEL ) );
  136.  
  137.   BlockSignals( False, SIGUSR1);
  138. #ifndef DONT_REINSTALL_SIG
  139.   signal(SIGUSR1, SIGNAL_CAST sig_usr1);
  140. #endif
  141.   return(0);
  142. }
  143. #endif /* SIGUSR1 */
  144.  
  145.  
  146. /*******************************************************************
  147.   get ready for syslog stuff
  148.   ******************************************************************/
  149. void setup_logging(char *pname,BOOL interactive)
  150. {
  151. #ifdef SYSLOG
  152.   if (!interactive) {
  153.     char *p = strrchr(pname,'/');
  154.     if (p) pname = p+1;
  155. #ifdef LOG_DAEMON
  156.     openlog(pname, LOG_PID, SYSLOG_FACILITY);
  157. #else /* for old systems that have no facility codes. */
  158.     openlog(pname, LOG_PID);
  159. #endif
  160.   }
  161. #endif
  162.   if (interactive) {
  163.     stdout_logging = True;
  164.     dbf = stdout;
  165.   }
  166. }
  167.  
  168.  
  169. BOOL append_log=False;
  170.  
  171.  
  172. /****************************************************************************
  173. reopen the log files
  174. ****************************************************************************/
  175. void reopen_logs(void)
  176. {
  177.   pstring fname;
  178.   
  179.   if (DEBUGLEVEL > 0)
  180.   {
  181.     pstrcpy(fname,debugf);
  182.     if (lp_loaded() && (*lp_logfile()))
  183.       pstrcpy(fname,lp_logfile());
  184.  
  185.     if (!strcsequal(fname,debugf) || !dbf || !file_exist(debugf,NULL))
  186.     {
  187.       int oldumask = umask(022);
  188.       pstrcpy(debugf,fname);
  189.       if (dbf)
  190.         fclose(dbf);
  191.       if (append_log)
  192.         dbf = fopen(debugf,"a");
  193.       else
  194.         dbf = fopen(debugf,"w");
  195.       /*
  196.        * Fix from klausr@ITAP.Physik.Uni-Stuttgart.De
  197.        * to fix problem where smbd's that generate less
  198.        * than 100 messages keep growing the log.
  199.        */
  200.       force_check_log_size();
  201.       if (dbf)
  202.         setbuf(dbf,NULL);
  203.       umask(oldumask);
  204.     }
  205.   }
  206.   else
  207.   {
  208.     if (dbf)
  209.     {
  210.       fclose(dbf);
  211.       dbf = NULL;
  212.     }
  213.   }
  214. }
  215.  
  216. /*******************************************************************
  217.  Number of debug messages that have been output.
  218.  Used to check log size.
  219. ********************************************************************/
  220.  
  221. static int debug_count=0;
  222.  
  223. /*******************************************************************
  224.  Force a check of the log size.
  225. ********************************************************************/
  226.  
  227. void force_check_log_size(void)
  228. {
  229.   debug_count = 100;
  230. }
  231.  
  232. /*******************************************************************
  233.  Check if the log has grown too big
  234. ********************************************************************/
  235.  
  236. static void check_log_size(void)
  237. {
  238.   int maxlog;
  239.   struct stat st;
  240.  
  241.   if (debug_count++ < 100 || getuid() != 0)
  242.     return;
  243.  
  244.   maxlog = lp_max_log_size() * 1024;
  245.   if (!dbf || maxlog <= 0)
  246.     return;
  247.  
  248.   if (fstat(fileno(dbf),&st) == 0 && st.st_size > maxlog) {
  249.     fclose(dbf);
  250.     dbf = NULL;
  251.     reopen_logs();
  252.     if (dbf && file_size(debugf) > maxlog) {
  253.       pstring name;
  254.       fclose(dbf);
  255.       dbf = NULL;
  256.       slprintf(name,sizeof(name)-1,"%s.old",debugf);
  257.       rename(debugf,name);
  258.       reopen_logs();
  259.     }
  260.   }
  261.   debug_count=0;
  262. }
  263.  
  264.  
  265. /*******************************************************************
  266. write an debug message on the debugfile. This is called by the DEBUG
  267. macro
  268. ********************************************************************/
  269. #ifdef __STDC__
  270.  int Debug1(char *format_str, ...)
  271. {
  272. #else
  273.  int Debug1(va_alist)
  274. va_dcl
  275. {  
  276.   char *format_str;
  277. #endif
  278.   va_list ap;  
  279.   int old_errno = errno;
  280.  
  281.   if (stdout_logging) {
  282. #ifdef __STDC__
  283.     va_start(ap, format_str);
  284. #else
  285.     va_start(ap);
  286.     format_str = va_arg(ap,char *);
  287. #endif
  288.     vfprintf(dbf,format_str,ap);
  289.     va_end(ap);
  290.     errno = old_errno;
  291.     return(0);
  292.   }
  293.   
  294. #ifdef SYSLOG
  295.   if (!lp_syslog_only())
  296. #endif  
  297.     {
  298.       if (!dbf) {
  299.           int oldumask = umask(022);
  300.               if(append_log)
  301.                 dbf = fopen(debugf,"a");
  302.               else
  303.                 dbf = fopen(debugf,"w");
  304.           umask(oldumask);
  305.           if (dbf) {
  306.               setbuf(dbf,NULL);
  307.           } else {
  308.               errno = old_errno;
  309.               return(0);
  310.           }
  311.       }
  312.     }
  313.  
  314. #ifdef SYSLOG
  315.   if (syslog_level < lp_syslog())
  316.     {
  317.       /* 
  318.        * map debug levels to syslog() priorities
  319.        * note that not all DEBUG(0, ...) calls are
  320.        * necessarily errors
  321.        */
  322.       static int priority_map[] = { 
  323.     LOG_ERR,     /* 0 */
  324.     LOG_WARNING, /* 1 */
  325.     LOG_NOTICE,  /* 2 */
  326.     LOG_INFO,    /* 3 */
  327.       };
  328.       int priority;
  329.       pstring msgbuf;
  330.       
  331.       if (syslog_level >= sizeof(priority_map) / sizeof(priority_map[0]) ||
  332.       syslog_level < 0)
  333.     priority = LOG_DEBUG;
  334.       else
  335.     priority = priority_map[syslog_level];
  336.       
  337. #ifdef __STDC__
  338.       va_start(ap, format_str);
  339. #else
  340.       va_start(ap);
  341.       format_str = va_arg(ap,char *);
  342. #endif
  343.       vslprintf(msgbuf, sizeof(msgbuf)-1,format_str, ap);
  344.       va_end(ap);
  345.       
  346.       msgbuf[255] = '\0';
  347.       syslog(priority, "%s", msgbuf);
  348.     }
  349. #endif
  350.   
  351. #ifdef SYSLOG
  352.   if (!lp_syslog_only())
  353. #endif
  354.     {
  355. #ifdef __STDC__
  356.       va_start(ap, format_str);
  357. #else
  358.       va_start(ap);
  359.       format_str = va_arg(ap,char *);
  360. #endif
  361.       vfprintf(dbf,format_str,ap);
  362.       va_end(ap);
  363.       fflush(dbf);
  364.     }
  365.  
  366.   check_log_size();
  367.  
  368.   errno = old_errno;
  369.  
  370.   return(0);
  371. }
  372.  
  373. /****************************************************************************
  374.   find a suitable temporary directory. The result should be copied immediately
  375.   as it may be overwritten by a subsequent call
  376.   ****************************************************************************/
  377. char *tmpdir(void)
  378. {
  379.   char *p;
  380.   if ((p = getenv("TMPDIR"))) {
  381.     return p;
  382.   }
  383.   return "/tmp";
  384. }
  385.  
  386.  
  387.  
  388. /****************************************************************************
  389. determine if a file descriptor is in fact a socket
  390. ****************************************************************************/
  391. BOOL is_a_socket(int fd)
  392. {
  393.   int v,l;
  394.   l = sizeof(int);
  395.   return(getsockopt(fd, SOL_SOCKET, SO_TYPE, (char *)&v, &l) == 0);
  396. }
  397.  
  398.  
  399. static char *last_ptr=NULL;
  400.  
  401. /****************************************************************************
  402.   Get the next token from a string, return False if none found
  403.   handles double-quotes. 
  404. Based on a routine by GJC@VILLAGE.COM. 
  405. Extensively modified by Andrew.Tridgell@anu.edu.au
  406. ****************************************************************************/
  407. BOOL next_token(char **ptr,char *buff,char *sep)
  408. {
  409.   char *s;
  410.   BOOL quoted;
  411.  
  412.   if (!ptr) ptr = &last_ptr;
  413.   if (!ptr) return(False);
  414.  
  415.   s = *ptr;
  416.  
  417.   /* default to simple separators */
  418.   if (!sep) sep = " \t\n\r";
  419.  
  420.   /* find the first non sep char */
  421.   while(*s && strchr(sep,*s)) s++;
  422.  
  423.   /* nothing left? */
  424.   if (! *s) return(False);
  425.  
  426.   /* copy over the token */
  427.   for (quoted = False; *s && (quoted || !strchr(sep,*s)); s++)
  428.     {
  429.       if (*s == '\"') 
  430.     quoted = !quoted;
  431.       else
  432.     *buff++ = *s;
  433.     }
  434.  
  435.   *ptr = (*s) ? s+1 : s;  
  436.   *buff = 0;
  437.   last_ptr = *ptr;
  438.  
  439.   return(True);
  440. }
  441.  
  442. /****************************************************************************
  443. Convert list of tokens to array; dependent on above routine.
  444. Uses last_ptr from above - bit of a hack.
  445. ****************************************************************************/
  446. char **toktocliplist(int *ctok, char *sep)
  447. {
  448.   char *s=last_ptr;
  449.   int ictok=0;
  450.   char **ret, **iret;
  451.  
  452.   if (!sep) sep = " \t\n\r";
  453.  
  454.   while(*s && strchr(sep,*s)) s++;
  455.  
  456.   /* nothing left? */
  457.   if (!*s) return(NULL);
  458.  
  459.   do {
  460.     ictok++;
  461.     while(*s && (!strchr(sep,*s))) s++;
  462.     while(*s && strchr(sep,*s)) *s++=0;
  463.   } while(*s);
  464.  
  465.   *ctok=ictok;
  466.   s=last_ptr;
  467.  
  468.   if (!(ret=iret=malloc(ictok*sizeof(char *)))) return NULL;
  469.   
  470.   while(ictok--) {    
  471.     *iret++=s;
  472.     while(*s++);
  473.     while(!*s) s++;
  474.   }
  475.  
  476.   return ret;
  477. }
  478.  
  479. #ifndef HAVE_MEMMOVE
  480. /*******************************************************************
  481. safely copies memory, ensuring no overlap problems.
  482. this is only used if the machine does not have it's own memmove().
  483. this is not the fastest algorithm in town, but it will do for our
  484. needs.
  485. ********************************************************************/
  486. void *MemMove(void *dest,void *src,int size)
  487. {
  488.   unsigned long d,s;
  489.   int i;
  490.   if (dest==src || !size) return(dest);
  491.  
  492.   d = (unsigned long)dest;
  493.   s = (unsigned long)src;
  494.  
  495.   if ((d >= (s+size)) || (s >= (d+size))) {
  496.     /* no overlap */
  497.     memcpy(dest,src,size);
  498.     return(dest);
  499.   }
  500.  
  501.   if (d < s)
  502.     {
  503.       /* we can forward copy */
  504.       if (s-d >= sizeof(int) && 
  505.       !(s%sizeof(int)) && !(d%sizeof(int)) && !(size%sizeof(int))) {
  506.     /* do it all as words */
  507.     int *idest = (int *)dest;
  508.     int *isrc = (int *)src;
  509.     size /= sizeof(int);
  510.     for (i=0;i<size;i++) idest[i] = isrc[i];
  511.       } else {
  512.     /* simplest */
  513.     char *cdest = (char *)dest;
  514.     char *csrc = (char *)src;
  515.     for (i=0;i<size;i++) cdest[i] = csrc[i];
  516.       }
  517.     }
  518.   else
  519.     {
  520.       /* must backward copy */
  521.       if (d-s >= sizeof(int) && 
  522.       !(s%sizeof(int)) && !(d%sizeof(int)) && !(size%sizeof(int))) {
  523.     /* do it all as words */
  524.     int *idest = (int *)dest;
  525.     int *isrc = (int *)src;
  526.     size /= sizeof(int);
  527.     for (i=size-1;i>=0;i--) idest[i] = isrc[i];
  528.       } else {
  529.     /* simplest */
  530.     char *cdest = (char *)dest;
  531.     char *csrc = (char *)src;
  532.     for (i=size-1;i>=0;i--) cdest[i] = csrc[i];
  533.       }      
  534.     }
  535.   return(dest);
  536. }
  537. #endif
  538.  
  539.  
  540. /****************************************************************************
  541. prompte a dptr (to make it recently used)
  542. ****************************************************************************/
  543. void array_promote(char *array,int elsize,int element)
  544. {
  545.   char *p;
  546.   if (element == 0)
  547.     return;
  548.  
  549.   p = (char *)malloc(elsize);
  550.  
  551.   if (!p)
  552.     {
  553.       DEBUG(5,("Ahh! Can't malloc\n"));
  554.       return;
  555.     }
  556.   memcpy(p,array + element * elsize, elsize);
  557.   memmove(array + elsize,array,elsize*element);
  558.   memcpy(array,p,elsize);
  559.   free(p);
  560. }
  561.  
  562. enum SOCK_OPT_TYPES {OPT_BOOL,OPT_INT,OPT_ON};
  563.  
  564. struct
  565. {
  566.   char *name;
  567.   int level;
  568.   int option;
  569.   int value;
  570.   int opttype;
  571. } socket_options[] = {
  572.   {"SO_KEEPALIVE",      SOL_SOCKET,    SO_KEEPALIVE,    0,                 OPT_BOOL},
  573.   {"SO_REUSEADDR",      SOL_SOCKET,    SO_REUSEADDR,    0,                 OPT_BOOL},
  574.   {"SO_BROADCAST",      SOL_SOCKET,    SO_BROADCAST,    0,                 OPT_BOOL},
  575. #ifdef TCP_NODELAY
  576.   {"TCP_NODELAY",       IPPROTO_TCP,   TCP_NODELAY,     0,                 OPT_BOOL},
  577. #endif
  578. #ifdef IPTOS_LOWDELAY
  579.   {"IPTOS_LOWDELAY",    IPPROTO_IP,    IP_TOS,          IPTOS_LOWDELAY,    OPT_ON},
  580. #endif
  581. #ifdef IPTOS_THROUGHPUT
  582.   {"IPTOS_THROUGHPUT",  IPPROTO_IP,    IP_TOS,          IPTOS_THROUGHPUT,  OPT_ON},
  583. #endif
  584. #ifdef SO_SNDBUF
  585.   {"SO_SNDBUF",         SOL_SOCKET,    SO_SNDBUF,       0,                 OPT_INT},
  586. #endif
  587. #ifdef SO_RCVBUF
  588.   {"SO_RCVBUF",         SOL_SOCKET,    SO_RCVBUF,       0,                 OPT_INT},
  589. #endif
  590. #ifdef SO_SNDLOWAT
  591.   {"SO_SNDLOWAT",       SOL_SOCKET,    SO_SNDLOWAT,     0,                 OPT_INT},
  592. #endif
  593. #ifdef SO_RCVLOWAT
  594.   {"SO_RCVLOWAT",       SOL_SOCKET,    SO_RCVLOWAT,     0,                 OPT_INT},
  595. #endif
  596. #ifdef SO_SNDTIMEO
  597.   {"SO_SNDTIMEO",       SOL_SOCKET,    SO_SNDTIMEO,     0,                 OPT_INT},
  598. #endif
  599. #ifdef SO_RCVTIMEO
  600.   {"SO_RCVTIMEO",       SOL_SOCKET,    SO_RCVTIMEO,     0,                 OPT_INT},
  601. #endif
  602.   {NULL,0,0,0,0}};
  603.  
  604.     
  605.  
  606. /****************************************************************************
  607. set user socket options
  608. ****************************************************************************/
  609. void set_socket_options(int fd, char *options)
  610. {
  611.   fstring tok;
  612.  
  613.   while (next_token(&options,tok," \t,"))
  614.     {
  615.       int ret=0,i;
  616.       int value = 1;
  617.       char *p;
  618.       BOOL got_value = False;
  619.  
  620.       if ((p = strchr(tok,'=')))
  621.     {
  622.       *p = 0;
  623.       value = atoi(p+1);
  624.       got_value = True;
  625.     }
  626.  
  627.       for (i=0;socket_options[i].name;i++)
  628.     if (strequal(socket_options[i].name,tok))
  629.       break;
  630.  
  631.       if (!socket_options[i].name)
  632.     {
  633.       DEBUG(0,("Unknown socket option %s\n",tok));
  634.       continue;
  635.     }
  636.  
  637.       switch (socket_options[i].opttype)
  638.     {
  639.     case OPT_BOOL:
  640.     case OPT_INT:
  641.       ret = setsockopt(fd,socket_options[i].level,
  642.                socket_options[i].option,(char *)&value,sizeof(int));
  643.       break;
  644.  
  645.     case OPT_ON:
  646.       if (got_value)
  647.         DEBUG(0,("syntax error - %s does not take a value\n",tok));
  648.  
  649.       {
  650.         int on = socket_options[i].value;
  651.         ret = setsockopt(fd,socket_options[i].level,
  652.                  socket_options[i].option,(char *)&on,sizeof(int));
  653.       }
  654.       break;      
  655.     }
  656.       
  657.       if (ret != 0)
  658.     DEBUG(0,("Failed to set socket option %s\n",tok));
  659.     }
  660. }
  661.  
  662.  
  663.  
  664. /****************************************************************************
  665.   close the socket communication
  666. ****************************************************************************/
  667. void close_sockets(void )
  668. {
  669.   close(Client);
  670.   Client = 0;
  671. }
  672.  
  673. /****************************************************************************
  674. determine whether we are in the specified group
  675. ****************************************************************************/
  676. BOOL in_group(gid_t group, int current_gid, int ngroups, int *groups)
  677. {
  678.   int i;
  679.  
  680.   if (group == current_gid) return(True);
  681.  
  682.   for (i=0;i<ngroups;i++)
  683.     if (group == groups[i])
  684.       return(True);
  685.  
  686.   return(False);
  687. }
  688.  
  689. /****************************************************************************
  690. this is a safer strcpy(), meant to prevent core dumps when nasty things happen
  691. ****************************************************************************/
  692. char *StrCpy(char *dest,char *src)
  693. {
  694.   char *d = dest;
  695.  
  696. #if AJT
  697.   /* I don't want to get lazy with these ... */
  698.   if (!dest || !src) {
  699.     DEBUG(0,("ERROR: NULL StrCpy() called!\n"));
  700.     ajt_panic();
  701.   }
  702. #endif
  703.  
  704.   if (!dest) return(NULL);
  705.   if (!src) {
  706.     *dest = 0;
  707.     return(dest);
  708.   }
  709.   while ((*d++ = *src++)) ;
  710.   return(dest);
  711. }
  712.  
  713. /****************************************************************************
  714. line strncpy but always null terminates. Make sure there is room!
  715. ****************************************************************************/
  716. char *StrnCpy(char *dest,char *src,int n)
  717. {
  718.   char *d = dest;
  719.   if (!dest) return(NULL);
  720.   if (!src) {
  721.     *dest = 0;
  722.     return(dest);
  723.   }
  724.   while (n-- && (*d++ = *src++)) ;
  725.   *d = 0;
  726.   return(dest);
  727. }
  728.  
  729.  
  730. /*******************************************************************
  731. copy an IP address from one buffer to another
  732. ********************************************************************/
  733. void putip(void *dest,void *src)
  734. {
  735.   memcpy(dest,src,4);
  736. }
  737.  
  738.  
  739. /****************************************************************************
  740. interpret the weird netbios "name". Return the name type
  741. ****************************************************************************/
  742. static int name_interpret(char *in,char *out)
  743. {
  744.   int ret;
  745.   int len = (*in++) / 2;
  746.  
  747.   *out=0;
  748.  
  749.   if (len > 30 || len<1) return(0);
  750.  
  751.   while (len--)
  752.     {
  753.       if (in[0] < 'A' || in[0] > 'P' || in[1] < 'A' || in[1] > 'P') {
  754.     *out = 0;
  755.     return(0);
  756.       }
  757.       *out = ((in[0]-'A')<<4) + (in[1]-'A');
  758.       in += 2;
  759.       out++;
  760.     }
  761.   *out = 0;
  762.   ret = out[-1];
  763.  
  764. #ifdef NETBIOS_SCOPE
  765.   /* Handle any scope names */
  766.   while(*in) 
  767.     {
  768.       *out++ = '.'; /* Scope names are separated by periods */
  769.       len = *(unsigned char *)in++;
  770.       StrnCpy(out, in, len);
  771.       out += len;
  772.       *out=0;
  773.       in += len;
  774.     }
  775. #endif
  776.   return(ret);
  777. }
  778.  
  779. /****************************************************************************
  780. mangle a name into netbios format
  781.  
  782.   Note:  <Out> must be (33 + strlen(scope) + 2) bytes long, at minimum.
  783. ****************************************************************************/
  784. int name_mangle( char *In, char *Out, char name_type )
  785.   {
  786.   int   i;
  787.   int   c;
  788.   int   len;
  789.   char  buf[20];
  790.   char *p = Out;
  791.  
  792.   /* Safely copy the input string, In, into buf[]. */
  793.   (void)memset( buf, 0, 20 );
  794.   if( '*' == In[0] )
  795.     buf[0] = '*';
  796.   else
  797.     (void)slprintf( buf, sizeof(buf)-1, "%-15.15s%c", In, name_type );
  798.  
  799.   /* Place the length of the first field into the output buffer. */
  800.   p[0] = 32;
  801.   p++;
  802.  
  803.   /* Now convert the name to the rfc1001/1002 format. */
  804.   for( i = 0; i < 16; i++ )
  805.     {
  806.     c = toupper( buf[i] );
  807.     p[i*2]     = ( (c >> 4) & 0x000F ) + 'A';
  808.     p[(i*2)+1] = (c & 0x000F) + 'A';
  809.     }
  810.   p += 32;
  811.   p[0] = '\0';
  812.  
  813.   /* Add the scope string. */
  814.   for( i = 0, len = 0; NULL != scope; i++, len++ )
  815.     {
  816.     switch( scope[i] )
  817.       {
  818.       case '\0':
  819.         p[0]     = len;
  820.         if( len > 0 )
  821.           p[len+1] = 0;
  822.         return( name_len(Out) );
  823.       case '.':
  824.         p[0] = len;
  825.         p   += (len + 1);
  826.         len  = 0;
  827.         break;
  828.       default:
  829.         p[len+1] = scope[i];
  830.         break;
  831.       }
  832.     }
  833.  
  834.   return( name_len(Out) );
  835.   } /* name_mangle */
  836.  
  837. /*******************************************************************
  838.   check if a file exists
  839. ********************************************************************/
  840. BOOL file_exist(char *fname,struct stat *sbuf)
  841. {
  842.   struct stat st;
  843.   if (!sbuf) sbuf = &st;
  844.   
  845.   if (sys_stat(fname,sbuf) != 0) 
  846.     return(False);
  847.  
  848.   return(S_ISREG(sbuf->st_mode));
  849. }
  850.  
  851. /*******************************************************************
  852. check a files mod time
  853. ********************************************************************/
  854. time_t file_modtime(char *fname)
  855. {
  856.   struct stat st;
  857.   
  858.   if (sys_stat(fname,&st) != 0) 
  859.     return(0);
  860.  
  861.   return(st.st_mtime);
  862. }
  863.  
  864. /*******************************************************************
  865.   check if a directory exists
  866. ********************************************************************/
  867. BOOL directory_exist(char *dname,struct stat *st)
  868. {
  869.   struct stat st2;
  870.   BOOL ret;
  871.  
  872.   if (!st) st = &st2;
  873.  
  874.   if (sys_stat(dname,st) != 0) 
  875.     return(False);
  876.  
  877.   ret = S_ISDIR(st->st_mode);
  878.   if(!ret)
  879.     errno = ENOTDIR;
  880.   return ret;
  881. }
  882.  
  883. /*******************************************************************
  884. returns the size in bytes of the named file
  885. ********************************************************************/
  886. uint32 file_size(char *file_name)
  887. {
  888.   struct stat buf;
  889.   buf.st_size = 0;
  890.   sys_stat(file_name,&buf);
  891.   return(buf.st_size);
  892. }
  893.  
  894. /*******************************************************************
  895. return a string representing an attribute for a file
  896. ********************************************************************/
  897. char *attrib_string(int mode)
  898. {
  899.   static fstring attrstr;
  900.  
  901.   attrstr[0] = 0;
  902.  
  903.   if (mode & aVOLID) fstrcat(attrstr,"V");
  904.   if (mode & aDIR) fstrcat(attrstr,"D");
  905.   if (mode & aARCH) fstrcat(attrstr,"A");
  906.   if (mode & aHIDDEN) fstrcat(attrstr,"H");
  907.   if (mode & aSYSTEM) fstrcat(attrstr,"S");
  908.   if (mode & aRONLY) fstrcat(attrstr,"R");      
  909.  
  910.   return(attrstr);
  911. }
  912.  
  913.  
  914. /*******************************************************************
  915.   case insensitive string compararison
  916. ********************************************************************/
  917. int StrCaseCmp(char *s, char *t)
  918. {
  919.   /* compare until we run out of string, either t or s, or find a difference */
  920.   /* We *must* use toupper rather than tolower here due to the
  921.      asynchronous upper to lower mapping.
  922.    */
  923. #if !defined(KANJI_WIN95_COMPATIBILITY)
  924.   /*
  925.    * For completeness we should put in equivalent code for code pages
  926.    * 949 (Korean hangul) and 950 (Big5 Traditional Chinese) here - but
  927.    * doubt anyone wants Samba to behave differently from Win95 and WinNT
  928.    * here. They both treat full width ascii characters as case senstive
  929.    * filenames (ie. they don't do the work we do here).
  930.    * JRA.
  931.    */
  932.  
  933.   if(lp_client_code_page() == KANJI_CODEPAGE)
  934.   {
  935.     /* Win95 treats full width ascii characters as case sensitive. */
  936.     int diff;
  937.     for (;;)
  938.     {
  939.       if (!*s || !*t)
  940.         return toupper (*s) - toupper (*t);
  941.       else if (is_sj_alph (*s) && is_sj_alph (*t))
  942.       {
  943.         diff = sj_toupper2 (*(s+1)) - sj_toupper2 (*(t+1));
  944.         if (diff)
  945.           return diff;
  946.         s += 2;
  947.         t += 2;
  948.       }
  949.       else if (is_shift_jis (*s) && is_shift_jis (*t))
  950.       {
  951.         diff = ((int) (unsigned char) *s) - ((int) (unsigned char) *t);
  952.         if (diff)
  953.           return diff;
  954.         diff = ((int) (unsigned char) *(s+1)) - ((int) (unsigned char) *(t+1));
  955.         if (diff)
  956.           return diff;
  957.         s += 2;
  958.         t += 2;
  959.       }
  960.       else if (is_shift_jis (*s))
  961.         return 1;
  962.       else if (is_shift_jis (*t))
  963.         return -1;
  964.       else 
  965.       {
  966.         diff = toupper (*s) - toupper (*t);
  967.         if (diff)
  968.           return diff;
  969.         s++;
  970.         t++;
  971.       }
  972.     }
  973.   }
  974.   else
  975. #endif /* KANJI_WIN95_COMPATIBILITY */
  976.   {
  977.     while (*s && *t && toupper(*s) == toupper(*t))
  978.     {
  979.       s++;
  980.       t++;
  981.     }
  982.  
  983.     return(toupper(*s) - toupper(*t));
  984.   }
  985. }
  986.  
  987. /*******************************************************************
  988.   case insensitive string compararison, length limited
  989. ********************************************************************/
  990. int StrnCaseCmp(char *s, char *t, int n)
  991. {
  992.   /* compare until we run out of string, either t or s, or chars */
  993.   /* We *must* use toupper rather than tolower here due to the
  994.      asynchronous upper to lower mapping.
  995.    */
  996. #if !defined(KANJI_WIN95_COMPATIBILITY)
  997.   /*
  998.    * For completeness we should put in equivalent code for code pages
  999.    * 949 (Korean hangul) and 950 (Big5 Traditional Chinese) here - but
  1000.    * doubt anyone wants Samba to behave differently from Win95 and WinNT
  1001.    * here. They both treat full width ascii characters as case senstive
  1002.    * filenames (ie. they don't do the work we do here).
  1003.    * JRA. 
  1004.    */
  1005.  
  1006.   if(lp_client_code_page() == KANJI_CODEPAGE)
  1007.   {
  1008.     /* Win95 treats full width ascii characters as case sensitive. */
  1009.     int diff;
  1010.     for (;n > 0;)
  1011.     {
  1012.       if (!*s || !*t)
  1013.         return toupper (*s) - toupper (*t);
  1014.       else if (is_sj_alph (*s) && is_sj_alph (*t))
  1015.       {
  1016.         diff = sj_toupper2 (*(s+1)) - sj_toupper2 (*(t+1));
  1017.         if (diff)
  1018.           return diff;
  1019.         s += 2;
  1020.         t += 2;
  1021.         n -= 2;
  1022.       }
  1023.       else if (is_shift_jis (*s) && is_shift_jis (*t))
  1024.       {
  1025.         diff = ((int) (unsigned char) *s) - ((int) (unsigned char) *t);
  1026.         if (diff)
  1027.           return diff;
  1028.         diff = ((int) (unsigned char) *(s+1)) - ((int) (unsigned char) *(t+1));
  1029.         if (diff)
  1030.           return diff;
  1031.         s += 2;
  1032.         t += 2;
  1033.         n -= 2;
  1034.       }
  1035.       else if (is_shift_jis (*s))
  1036.         return 1;
  1037.       else if (is_shift_jis (*t))
  1038.         return -1;
  1039.       else 
  1040.       {
  1041.         diff = toupper (*s) - toupper (*t);
  1042.         if (diff)
  1043.           return diff;
  1044.         s++;
  1045.         t++;
  1046.         n--;
  1047.       }
  1048.     }
  1049.     return 0;
  1050.   }
  1051.   else
  1052. #endif /* KANJI_WIN95_COMPATIBILITY */
  1053.   {
  1054.     while (n && *s && *t && toupper(*s) == toupper(*t))
  1055.     {
  1056.       s++;
  1057.       t++;
  1058.       n--;
  1059.     }
  1060.  
  1061.     /* not run out of chars - strings are different lengths */
  1062.     if (n) 
  1063.       return(toupper(*s) - toupper(*t));
  1064.  
  1065.     /* identical up to where we run out of chars, 
  1066.        and strings are same length */
  1067.     return(0);
  1068.   }
  1069. }
  1070.  
  1071. /*******************************************************************
  1072.   compare 2 strings 
  1073. ********************************************************************/
  1074. BOOL strequal(char *s1, char *s2)
  1075. {
  1076.   if (s1 == s2) return(True);
  1077.   if (!s1 || !s2) return(False);
  1078.   
  1079.   return(StrCaseCmp(s1,s2)==0);
  1080. }
  1081.  
  1082. /*******************************************************************
  1083.   compare 2 strings up to and including the nth char.
  1084.   ******************************************************************/
  1085. BOOL strnequal(char *s1,char *s2,int n)
  1086. {
  1087.   if (s1 == s2) return(True);
  1088.   if (!s1 || !s2 || !n) return(False);
  1089.   
  1090.   return(StrnCaseCmp(s1,s2,n)==0);
  1091. }
  1092.  
  1093. /*******************************************************************
  1094.   compare 2 strings (case sensitive)
  1095. ********************************************************************/
  1096. BOOL strcsequal(char *s1,char *s2)
  1097. {
  1098.   if (s1 == s2) return(True);
  1099.   if (!s1 || !s2) return(False);
  1100.   
  1101.   return(strcmp(s1,s2)==0);
  1102. }
  1103.  
  1104.  
  1105. /*******************************************************************
  1106.   convert a string to lower case
  1107. ********************************************************************/
  1108. void strlower(char *s)
  1109. {
  1110.   while (*s)
  1111.   {
  1112. #if !defined(KANJI_WIN95_COMPATIBILITY)
  1113.   /*
  1114.    * For completeness we should put in equivalent code for code pages
  1115.    * 949 (Korean hangul) and 950 (Big5 Traditional Chinese) here - but
  1116.    * doubt anyone wants Samba to behave differently from Win95 and WinNT
  1117.    * here. They both treat full width ascii characters as case senstive
  1118.    * filenames (ie. they don't do the work we do here).
  1119.    * JRA. 
  1120.    */
  1121.  
  1122.     if(lp_client_code_page() == KANJI_CODEPAGE)
  1123.     {
  1124.       /* Win95 treats full width ascii characters as case sensitive. */
  1125.       if (is_shift_jis (*s))
  1126.       {
  1127.         if (is_sj_upper (s[0], s[1]))
  1128.           s[1] = sj_tolower2 (s[1]);
  1129.         s += 2;
  1130.       }
  1131.       else if (is_kana (*s))
  1132.       {
  1133.         s++;
  1134.       }
  1135.       else
  1136.       {
  1137.         if (isupper(*s))
  1138.           *s = tolower(*s);
  1139.         s++;
  1140.       }
  1141.     }
  1142.     else
  1143. #endif /* KANJI_WIN95_COMPATIBILITY */
  1144.     {
  1145.       int skip = skip_multibyte_char( *s );
  1146.       if( skip != 0 )
  1147.         s += skip;
  1148.       else
  1149.       {
  1150.         if (isupper(*s))
  1151.           *s = tolower(*s);
  1152.         s++;
  1153.       }
  1154.     }
  1155.   }
  1156. }
  1157.  
  1158. /*******************************************************************
  1159.   convert a string to upper case
  1160. ********************************************************************/
  1161. void strupper(char *s)
  1162. {
  1163.   while (*s)
  1164.   {
  1165. #if !defined(KANJI_WIN95_COMPATIBILITY)
  1166.   /*
  1167.    * For completeness we should put in equivalent code for code pages
  1168.    * 949 (Korean hangul) and 950 (Big5 Traditional Chinese) here - but
  1169.    * doubt anyone wants Samba to behave differently from Win95 and WinNT
  1170.    * here. They both treat full width ascii characters as case senstive
  1171.    * filenames (ie. they don't do the work we do here).
  1172.    * JRA. 
  1173.    */
  1174.  
  1175.     if(lp_client_code_page() == KANJI_CODEPAGE)
  1176.     {
  1177.       /* Win95 treats full width ascii characters as case sensitive. */
  1178.       if (is_shift_jis (*s))
  1179.       {
  1180.         if (is_sj_lower (s[0], s[1]))
  1181.           s[1] = sj_toupper2 (s[1]);
  1182.         s += 2;
  1183.       }
  1184.       else if (is_kana (*s))
  1185.       {
  1186.         s++;
  1187.       }
  1188.       else
  1189.       {
  1190.         if (islower(*s))
  1191.           *s = toupper(*s);
  1192.         s++;
  1193.       }
  1194.     }
  1195.     else
  1196. #endif /* KANJI_WIN95_COMPATIBILITY */
  1197.     {
  1198.       int skip = skip_multibyte_char( *s );
  1199.       if( skip != 0 )
  1200.         s += skip;
  1201.       else
  1202.       {
  1203.         if (islower(*s))
  1204.           *s = toupper(*s);
  1205.         s++;
  1206.       }
  1207.     }
  1208.   }
  1209. }
  1210.  
  1211. /*******************************************************************
  1212.   convert a string to "normal" form
  1213. ********************************************************************/
  1214. void strnorm(char *s)
  1215. {
  1216.   if (case_default == CASE_UPPER)
  1217.     strupper(s);
  1218.   else
  1219.     strlower(s);
  1220. }
  1221.  
  1222. /*******************************************************************
  1223. check if a string is in "normal" case
  1224. ********************************************************************/
  1225. BOOL strisnormal(char *s)
  1226. {
  1227.   if (case_default == CASE_UPPER)
  1228.     return(!strhaslower(s));
  1229.  
  1230.   return(!strhasupper(s));
  1231. }
  1232.  
  1233.  
  1234. /****************************************************************************
  1235.   string replace
  1236. ****************************************************************************/
  1237. void string_replace(char *s,char oldc,char newc)
  1238. {
  1239.   int skip;
  1240.   while (*s)
  1241.   {
  1242.     skip = skip_multibyte_char( *s );
  1243.     if( skip != 0 )
  1244.       s += skip;
  1245.     else
  1246.     {
  1247.       if (oldc == *s)
  1248.         *s = newc;
  1249.       s++;
  1250.     }
  1251.   }
  1252. }
  1253.  
  1254. /****************************************************************************
  1255.   make a file into unix format
  1256. ****************************************************************************/
  1257. void unix_format(char *fname)
  1258. {
  1259.   pstring namecopy;
  1260.   string_replace(fname,'\\','/');
  1261.  
  1262.   if (*fname == '/')
  1263.     {
  1264.       pstrcpy(namecopy,fname);
  1265.       pstrcpy(fname,".");
  1266.       pstrcat(fname,namecopy);
  1267.     }  
  1268. }
  1269.  
  1270. /****************************************************************************
  1271.   make a file into dos format
  1272. ****************************************************************************/
  1273. void dos_format(char *fname)
  1274. {
  1275.   string_replace(fname,'/','\\');
  1276. }
  1277.  
  1278.  
  1279. /*******************************************************************
  1280.   show a smb message structure
  1281. ********************************************************************/
  1282. void show_msg(char *buf)
  1283. {
  1284.   int i;
  1285.   int bcc=0;
  1286.  
  1287.   if (DEBUGLEVEL < 5) return;
  1288.  
  1289.   DEBUG(5,("size=%d\nsmb_com=0x%x\nsmb_rcls=%d\nsmb_reh=%d\nsmb_err=%d\nsmb_flg=%d\nsmb_flg2=%d\n",
  1290.       smb_len(buf),
  1291.       (int)CVAL(buf,smb_com),
  1292.       (int)CVAL(buf,smb_rcls),
  1293.       (int)CVAL(buf,smb_reh),
  1294.       (int)SVAL(buf,smb_err),
  1295.       (int)CVAL(buf,smb_flg),
  1296.       (int)SVAL(buf,smb_flg2)));
  1297.   DEBUG(5,("smb_tid=%d\nsmb_pid=%d\nsmb_uid=%d\nsmb_mid=%d\nsmt_wct=%d\n",
  1298.       (int)SVAL(buf,smb_tid),
  1299.       (int)SVAL(buf,smb_pid),
  1300.       (int)SVAL(buf,smb_uid),
  1301.       (int)SVAL(buf,smb_mid),
  1302.       (int)CVAL(buf,smb_wct)));
  1303.  
  1304.   for (i=0;i<(int)CVAL(buf,smb_wct);i++)
  1305.     DEBUG(5,("smb_vwv[%d]=%d (0x%X)\n",i,
  1306.       SVAL(buf,smb_vwv+2*i),SVAL(buf,smb_vwv+2*i)));
  1307.  
  1308.   bcc = (int)SVAL(buf,smb_vwv+2*(CVAL(buf,smb_wct)));
  1309.   DEBUG(5,("smb_bcc=%d\n",bcc));
  1310.  
  1311.   if (DEBUGLEVEL < 10) return;
  1312.  
  1313.   dump_data(10, smb_buf(buf), MIN(bcc, 512));
  1314. }
  1315.  
  1316. /*******************************************************************
  1317.   return the length of an smb packet
  1318. ********************************************************************/
  1319. int smb_len(char *buf)
  1320. {
  1321.   return( PVAL(buf,3) | (PVAL(buf,2)<<8) | ((PVAL(buf,1)&1)<<16) );
  1322. }
  1323.  
  1324. /*******************************************************************
  1325.   set the length of an smb packet
  1326. ********************************************************************/
  1327. void _smb_setlen(char *buf,int len)
  1328. {
  1329.   buf[0] = 0;
  1330.   buf[1] = (len&0x10000)>>16;
  1331.   buf[2] = (len&0xFF00)>>8;
  1332.   buf[3] = len&0xFF;
  1333. }
  1334.  
  1335. /*******************************************************************
  1336.   set the length and marker of an smb packet
  1337. ********************************************************************/
  1338. void smb_setlen(char *buf,int len)
  1339. {
  1340.   _smb_setlen(buf,len);
  1341.  
  1342.   CVAL(buf,4) = 0xFF;
  1343.   CVAL(buf,5) = 'S';
  1344.   CVAL(buf,6) = 'M';
  1345.   CVAL(buf,7) = 'B';
  1346. }
  1347.  
  1348. /*******************************************************************
  1349.   setup the word count and byte count for a smb message
  1350. ********************************************************************/
  1351. int set_message(char *buf,int num_words,int num_bytes,BOOL zero)
  1352. {
  1353.   if (zero)
  1354.     bzero(buf + smb_size,num_words*2 + num_bytes);
  1355.   CVAL(buf,smb_wct) = num_words;
  1356.   SSVAL(buf,smb_vwv + num_words*SIZEOFWORD,num_bytes);  
  1357.   smb_setlen(buf,smb_size + num_words*2 + num_bytes - 4);
  1358.   return (smb_size + num_words*2 + num_bytes);
  1359. }
  1360.  
  1361. /*******************************************************************
  1362. return the number of smb words
  1363. ********************************************************************/
  1364. int smb_numwords(char *buf)
  1365. {
  1366.   return (CVAL(buf,smb_wct));
  1367. }
  1368.  
  1369. /*******************************************************************
  1370. return the size of the smb_buf region of a message
  1371. ********************************************************************/
  1372. int smb_buflen(char *buf)
  1373. {
  1374.   return(SVAL(buf,smb_vwv0 + smb_numwords(buf)*2));
  1375. }
  1376.  
  1377. /*******************************************************************
  1378.   return a pointer to the smb_buf data area
  1379. ********************************************************************/
  1380. int smb_buf_ofs(char *buf)
  1381. {
  1382.   return (smb_size + CVAL(buf,smb_wct)*2);
  1383. }
  1384.  
  1385. /*******************************************************************
  1386.   return a pointer to the smb_buf data area
  1387. ********************************************************************/
  1388. char *smb_buf(char *buf)
  1389. {
  1390.   return (buf + smb_buf_ofs(buf));
  1391. }
  1392.  
  1393. /*******************************************************************
  1394. return the SMB offset into an SMB buffer
  1395. ********************************************************************/
  1396. int smb_offset(char *p,char *buf)
  1397. {
  1398.   return(PTR_DIFF(p,buf+4) + chain_size);
  1399. }
  1400.  
  1401.  
  1402. /*******************************************************************
  1403. skip past some strings in a buffer
  1404. ********************************************************************/
  1405. char *skip_string(char *buf,int n)
  1406. {
  1407.   while (n--)
  1408.     buf += strlen(buf) + 1;
  1409.   return(buf);
  1410. }
  1411.  
  1412. /*******************************************************************
  1413. trim the specified elements off the front and back of a string
  1414. ********************************************************************/
  1415. BOOL trim_string(char *s,char *front,char *back)
  1416. {
  1417.   BOOL ret = False;
  1418.   while (front && *front && strncmp(s,front,strlen(front)) == 0)
  1419.     {
  1420.       char *p = s;
  1421.       ret = True;
  1422.       while (1)
  1423.     {
  1424.       if (!(*p = p[strlen(front)]))
  1425.         break;
  1426.       p++;
  1427.     }
  1428.     }
  1429.   while (back && *back && strlen(s) >= strlen(back) && 
  1430.      (strncmp(s+strlen(s)-strlen(back),back,strlen(back))==0))  
  1431.     {
  1432.       ret = True;
  1433.       s[strlen(s)-strlen(back)] = 0;
  1434.     }
  1435.   return(ret);
  1436. }
  1437.  
  1438.  
  1439. /*******************************************************************
  1440. reduce a file name, removing .. elements.
  1441. ********************************************************************/
  1442. void dos_clean_name(char *s)
  1443. {
  1444.   char *p=NULL;
  1445.  
  1446.   DEBUG(3,("dos_clean_name [%s]\n",s));
  1447.  
  1448.   /* remove any double slashes */
  1449.   string_sub(s, "\\\\", "\\");
  1450.  
  1451.   while ((p = strstr(s,"\\..\\")) != NULL)
  1452.     {
  1453.       pstring s1;
  1454.  
  1455.       *p = 0;
  1456.       pstrcpy(s1,p+3);
  1457.  
  1458.       if ((p=strrchr(s,'\\')) != NULL)
  1459.     *p = 0;
  1460.       else
  1461.     *s = 0;
  1462.       pstrcat(s,s1);
  1463.     }  
  1464.  
  1465.   trim_string(s,NULL,"\\..");
  1466.  
  1467.   string_sub(s, "\\.\\", "\\");
  1468. }
  1469.  
  1470. /*******************************************************************
  1471. reduce a file name, removing .. elements. 
  1472. ********************************************************************/
  1473. void unix_clean_name(char *s)
  1474. {
  1475.   char *p=NULL;
  1476.  
  1477.   DEBUG(3,("unix_clean_name [%s]\n",s));
  1478.  
  1479.   /* remove any double slashes */
  1480.   string_sub(s, "//","/");
  1481.  
  1482.   /* Remove leading ./ characters */
  1483.   if(strncmp(s, "./", 2) == 0) {
  1484.     trim_string(s, "./", NULL);
  1485.     if(*s == 0)
  1486.       pstrcpy(s,"./");
  1487.   }
  1488.  
  1489.   while ((p = strstr(s,"/../")) != NULL)
  1490.     {
  1491.       pstring s1;
  1492.  
  1493.       *p = 0;
  1494.       pstrcpy(s1,p+3);
  1495.  
  1496.       if ((p=strrchr(s,'/')) != NULL)
  1497.     *p = 0;
  1498.       else
  1499.     *s = 0;
  1500.       pstrcat(s,s1);
  1501.     }  
  1502.  
  1503.   trim_string(s,NULL,"/..");
  1504. }
  1505.  
  1506.  
  1507. /*******************************************************************
  1508. a wrapper for the normal chdir() function
  1509. ********************************************************************/
  1510. int ChDir(char *path)
  1511. {
  1512.   int res;
  1513.   static pstring LastDir="";
  1514.  
  1515.   if (strcsequal(path,".")) return(0);
  1516.  
  1517.   if (*path == '/' && strcsequal(LastDir,path)) return(0);
  1518.   DEBUG(3,("chdir to %s\n",path));
  1519.   res = sys_chdir(path);
  1520.   if (!res)
  1521.     pstrcpy(LastDir,path);
  1522.   return(res);
  1523. }
  1524.  
  1525. /* number of list structures for a caching GetWd function. */
  1526. #define MAX_GETWDCACHE (50)
  1527.  
  1528. struct
  1529. {
  1530.   ino_t inode;
  1531.   dev_t dev;
  1532.   char *text;
  1533.   BOOL valid;
  1534. } ino_list[MAX_GETWDCACHE];
  1535.  
  1536. BOOL use_getwd_cache=True;
  1537.  
  1538. /*******************************************************************
  1539.   return the absolute current directory path
  1540. ********************************************************************/
  1541. char *GetWd(char *str)
  1542. {
  1543.   pstring s;
  1544.   static BOOL getwd_cache_init = False;
  1545.   struct stat st, st2;
  1546.   int i;
  1547.  
  1548.   *s = 0;
  1549.  
  1550.   if (!use_getwd_cache)
  1551.     return(sys_getwd(str));
  1552.  
  1553.   /* init the cache */
  1554.   if (!getwd_cache_init)
  1555.     {
  1556.       getwd_cache_init = True;
  1557.       for (i=0;i<MAX_GETWDCACHE;i++)
  1558.     {
  1559.       string_init(&ino_list[i].text,"");
  1560.       ino_list[i].valid = False;
  1561.     }
  1562.     }
  1563.  
  1564.   /*  Get the inode of the current directory, if this doesn't work we're
  1565.       in trouble :-) */
  1566.  
  1567.   if (stat(".",&st) == -1) 
  1568.     {
  1569.       DEBUG(0,("Very strange, couldn't stat \".\"\n"));
  1570.       return(sys_getwd(str));
  1571.     }
  1572.  
  1573.  
  1574.   for (i=0; i<MAX_GETWDCACHE; i++)
  1575.     if (ino_list[i].valid)
  1576.       {
  1577.  
  1578.     /*  If we have found an entry with a matching inode and dev number
  1579.         then find the inode number for the directory in the cached string.
  1580.         If this agrees with that returned by the stat for the current
  1581.         directory then all is o.k. (but make sure it is a directory all
  1582.         the same...) */
  1583.       
  1584.     if (st.st_ino == ino_list[i].inode &&
  1585.         st.st_dev == ino_list[i].dev)
  1586.       {
  1587.         if (stat(ino_list[i].text,&st2) == 0)
  1588.           {
  1589.         if (st.st_ino == st2.st_ino &&
  1590.             st.st_dev == st2.st_dev &&
  1591.             (st2.st_mode & S_IFMT) == S_IFDIR)
  1592.           {
  1593.             pstrcpy (str, ino_list[i].text);
  1594.  
  1595.             /* promote it for future use */
  1596.             array_promote((char *)&ino_list[0],sizeof(ino_list[0]),i);
  1597.             return (str);
  1598.           }
  1599.         else
  1600.           {
  1601.             /*  If the inode is different then something's changed, 
  1602.             scrub the entry and start from scratch. */
  1603.             ino_list[i].valid = False;
  1604.           }
  1605.           }
  1606.       }
  1607.       }
  1608.  
  1609.  
  1610.   /*  We don't have the information to hand so rely on traditional methods.
  1611.       The very slow getcwd, which spawns a process on some systems, or the
  1612.       not quite so bad getwd. */
  1613.  
  1614.   if (!sys_getwd(s))
  1615.     {
  1616.       DEBUG(0,("Getwd failed, errno %s\n",strerror(errno)));
  1617.       return (NULL);
  1618.     }
  1619.  
  1620.   pstrcpy(str,s);
  1621.  
  1622.   DEBUG(5,("GetWd %s, inode %d, dev %x\n",s,(int)st.st_ino,(int)st.st_dev));
  1623.  
  1624.   /* add it to the cache */
  1625.   i = MAX_GETWDCACHE - 1;
  1626.   string_set(&ino_list[i].text,s);
  1627.   ino_list[i].dev = st.st_dev;
  1628.   ino_list[i].inode = st.st_ino;
  1629.   ino_list[i].valid = True;
  1630.  
  1631.   /* put it at the top of the list */
  1632.   array_promote((char *)&ino_list[0],sizeof(ino_list[0]),i);
  1633.  
  1634.   return (str);
  1635. }
  1636.  
  1637.  
  1638.  
  1639. /*******************************************************************
  1640. reduce a file name, removing .. elements and checking that 
  1641. it is below dir in the heirachy. This uses GetWd() and so must be run
  1642. on the system that has the referenced file system.
  1643.  
  1644. widelinks are allowed if widelinks is true
  1645. ********************************************************************/
  1646. BOOL reduce_name(char *s,char *dir,BOOL widelinks)
  1647. {
  1648. #ifndef REDUCE_PATHS
  1649.   return True;
  1650. #else
  1651.   pstring dir2;
  1652.   pstring wd;
  1653.   pstring base_name;
  1654.   pstring newname;
  1655.   char *p=NULL;
  1656.   BOOL relative = (*s != '/');
  1657.  
  1658.   *dir2 = *wd = *base_name = *newname = 0;
  1659.  
  1660.   if (widelinks)
  1661.     {
  1662.       unix_clean_name(s);
  1663.       /* can't have a leading .. */
  1664.       if (strncmp(s,"..",2) == 0 && (s[2]==0 || s[2]=='/'))
  1665.     {
  1666.       DEBUG(3,("Illegal file name? (%s)\n",s));
  1667.       return(False);
  1668.     }
  1669.  
  1670.       if (strlen(s) == 0)
  1671.         pstrcpy(s,"./");
  1672.  
  1673.       return(True);
  1674.     }
  1675.   
  1676.   DEBUG(3,("reduce_name [%s] [%s]\n",s,dir));
  1677.  
  1678.   /* remove any double slashes */
  1679.   string_sub(s,"//","/");
  1680.  
  1681.   pstrcpy(base_name,s);
  1682.   p = strrchr(base_name,'/');
  1683.  
  1684.   if (!p)
  1685.     return(True);
  1686.  
  1687.   if (!GetWd(wd))
  1688.     {
  1689.       DEBUG(0,("couldn't getwd for %s %s\n",s,dir));
  1690.       return(False);
  1691.     }
  1692.  
  1693.   if (ChDir(dir) != 0)
  1694.     {
  1695.       DEBUG(0,("couldn't chdir to %s\n",dir));
  1696.       return(False);
  1697.     }
  1698.  
  1699.   if (!GetWd(dir2))
  1700.     {
  1701.       DEBUG(0,("couldn't getwd for %s\n",dir));
  1702.       ChDir(wd);
  1703.       return(False);
  1704.     }
  1705.  
  1706.  
  1707.     if (p && (p != base_name))
  1708.       {
  1709.     *p = 0;
  1710.     if (strcmp(p+1,".")==0)
  1711.       p[1]=0;
  1712.     if (strcmp(p+1,"..")==0)
  1713.       *p = '/';
  1714.       }
  1715.  
  1716.   if (ChDir(base_name) != 0)
  1717.     {
  1718.       ChDir(wd);
  1719.       DEBUG(3,("couldn't chdir for %s %s basename=%s\n",s,dir,base_name));
  1720.       return(False);
  1721.     }
  1722.  
  1723.   if (!GetWd(newname))
  1724.     {
  1725.       ChDir(wd);
  1726.       DEBUG(2,("couldn't get wd for %s %s\n",s,dir2));
  1727.       return(False);
  1728.     }
  1729.  
  1730.   if (p && (p != base_name))
  1731.     {
  1732.       pstrcat(newname,"/");
  1733.       pstrcat(newname,p+1);
  1734.     }
  1735.  
  1736.   {
  1737.     int l = strlen(dir2);    
  1738.     if (dir2[l-1] == '/')
  1739.       l--;
  1740.  
  1741.     if (strncmp(newname,dir2,l) != 0)
  1742.       {
  1743.     ChDir(wd);
  1744.     DEBUG(2,("Bad access attempt? s=%s dir=%s newname=%s l=%d\n",s,dir2,newname,l));
  1745.     return(False);
  1746.       }
  1747.  
  1748.     if (relative)
  1749.       {
  1750.     if (newname[l] == '/')
  1751.       pstrcpy(s,newname + l + 1);
  1752.     else
  1753.       pstrcpy(s,newname+l);
  1754.       }
  1755.     else
  1756.       pstrcpy(s,newname);
  1757.   }
  1758.  
  1759.   ChDir(wd);
  1760.  
  1761.   if (strlen(s) == 0)
  1762.     pstrcpy(s,"./");
  1763.  
  1764.   DEBUG(3,("reduced to %s\n",s));
  1765.   return(True);
  1766. #endif
  1767. }
  1768.  
  1769. /****************************************************************************
  1770. expand some *s 
  1771. ****************************************************************************/
  1772. static void expand_one(char *Mask,int len)
  1773. {
  1774.   char *p1;
  1775.   while ((p1 = strchr(Mask,'*')) != NULL)
  1776.     {
  1777.       int lfill = (len+1) - strlen(Mask);
  1778.       int l1= (p1 - Mask);
  1779.       pstring tmp;
  1780.       pstrcpy(tmp,Mask);  
  1781.       memset(tmp+l1,'?',lfill);
  1782.       pstrcpy(tmp + l1 + lfill,Mask + l1 + 1);    
  1783.       pstrcpy(Mask,tmp);      
  1784.     }
  1785. }
  1786.  
  1787. /****************************************************************************
  1788. expand a wildcard expression, replacing *s with ?s
  1789. ****************************************************************************/
  1790. void expand_mask(char *Mask,BOOL doext)
  1791. {
  1792.   pstring mbeg,mext;
  1793.   pstring dirpart;
  1794.   pstring filepart;
  1795.   BOOL hasdot = False;
  1796.   char *p1;
  1797.   BOOL absolute = (*Mask == '\\');
  1798.  
  1799.   *mbeg = *mext = *dirpart = *filepart = 0;
  1800.  
  1801.   /* parse the directory and filename */
  1802.   if (strchr(Mask,'\\'))
  1803.     dirname_dos(Mask,dirpart);
  1804.  
  1805.   filename_dos(Mask,filepart);
  1806.  
  1807.   pstrcpy(mbeg,filepart);
  1808.   if ((p1 = strchr(mbeg,'.')) != NULL)
  1809.     {
  1810.       hasdot = True;
  1811.       *p1 = 0;
  1812.       p1++;
  1813.       pstrcpy(mext,p1);
  1814.     }
  1815.   else
  1816.     {
  1817.       pstrcpy(mext,"");
  1818.       if (strlen(mbeg) > 8)
  1819.     {
  1820.       pstrcpy(mext,mbeg + 8);
  1821.       mbeg[8] = 0;
  1822.     }
  1823.     }
  1824.  
  1825.   if (*mbeg == 0)
  1826.     pstrcpy(mbeg,"????????");
  1827.   if ((*mext == 0) && doext && !hasdot)
  1828.     pstrcpy(mext,"???");
  1829.  
  1830.   if (strequal(mbeg,"*") && *mext==0) 
  1831.     pstrcpy(mext,"*");
  1832.  
  1833.   /* expand *'s */
  1834.   expand_one(mbeg,8);
  1835.   if (*mext)
  1836.     expand_one(mext,3);
  1837.  
  1838.   pstrcpy(Mask,dirpart);
  1839.   if (*dirpart || absolute) pstrcat(Mask,"\\");
  1840.   pstrcat(Mask,mbeg);
  1841.   pstrcat(Mask,".");
  1842.   pstrcat(Mask,mext);
  1843.  
  1844.   DEBUG(6,("Mask expanded to [%s]\n",Mask));
  1845. }  
  1846.  
  1847.  
  1848. /****************************************************************************
  1849. does a string have any uppercase chars in it?
  1850. ****************************************************************************/
  1851. BOOL strhasupper(char *s)
  1852. {
  1853.   while (*s) 
  1854.   {
  1855. #if !defined(KANJI_WIN95_COMPATIBILITY)
  1856.   /*
  1857.    * For completeness we should put in equivalent code for code pages
  1858.    * 949 (Korean hangul) and 950 (Big5 Traditional Chinese) here - but
  1859.    * doubt anyone wants Samba to behave differently from Win95 and WinNT
  1860.    * here. They both treat full width ascii characters as case senstive
  1861.    * filenames (ie. they don't do the work we do here).
  1862.    * JRA. 
  1863.    */
  1864.  
  1865.     if(lp_client_code_page() == KANJI_CODEPAGE)
  1866.     {
  1867.       /* Win95 treats full width ascii characters as case sensitive. */
  1868.       if (is_shift_jis (*s))
  1869.         s += 2;
  1870.       else if (is_kana (*s))
  1871.         s++;
  1872.       else
  1873.       {
  1874.         if (isupper(*s))
  1875.           return(True);
  1876.         s++;
  1877.       }
  1878.     }
  1879.     else
  1880. #endif /* KANJI_WIN95_COMPATIBILITY */
  1881.     {
  1882.       int skip = skip_multibyte_char( *s );
  1883.       if( skip != 0 )
  1884.         s += skip;
  1885.       else {
  1886.         if (isupper(*s))
  1887.           return(True);
  1888.         s++;
  1889.       }
  1890.     }
  1891.   }
  1892.   return(False);
  1893. }
  1894.  
  1895. /****************************************************************************
  1896. does a string have any lowercase chars in it?
  1897. ****************************************************************************/
  1898. BOOL strhaslower(char *s)
  1899. {
  1900.   while (*s) 
  1901.   {
  1902. #if !defined(KANJI_WIN95_COMPATIBILITY)
  1903.   /*
  1904.    * For completeness we should put in equivalent code for code pages
  1905.    * 949 (Korean hangul) and 950 (Big5 Traditional Chinese) here - but
  1906.    * doubt anyone wants Samba to behave differently from Win95 and WinNT
  1907.    * here. They both treat full width ascii characters as case senstive
  1908.    * filenames (ie. they don't do the work we do here).
  1909.    * JRA. 
  1910.    */
  1911.  
  1912.     if(lp_client_code_page() == KANJI_CODEPAGE)
  1913.     {
  1914.       /* Win95 treats full width ascii characters as case sensitive. */
  1915.       if (is_shift_jis (*s))
  1916.       {
  1917.         if (is_sj_upper (s[0], s[1]))
  1918.           return(True);
  1919.         if (is_sj_lower (s[0], s[1]))
  1920.           return (True);
  1921.         s += 2;
  1922.       }
  1923.       else if (is_kana (*s))
  1924.       {
  1925.         s++;
  1926.       }
  1927.       else
  1928.       {
  1929.         if (islower(*s))
  1930.           return(True);
  1931.         s++;
  1932.       }
  1933.     }
  1934.     else
  1935. #endif /* KANJI_WIN95_COMPATIBILITY */
  1936.     {
  1937.       int skip = skip_multibyte_char( *s );
  1938.       if( skip != 0 )
  1939.         s += skip;
  1940.       else {
  1941.         if (islower(*s))
  1942.           return(True);
  1943.         s++;
  1944.       }
  1945.     }
  1946.   }
  1947.   return(False);
  1948. }
  1949.  
  1950. /****************************************************************************
  1951. find the number of chars in a string
  1952. ****************************************************************************/
  1953. int count_chars(char *s,char c)
  1954. {
  1955.   int count=0;
  1956.  
  1957. #if !defined(KANJI_WIN95_COMPATIBILITY)
  1958.   /*
  1959.    * For completeness we should put in equivalent code for code pages
  1960.    * 949 (Korean hangul) and 950 (Big5 Traditional Chinese) here - but
  1961.    * doubt anyone wants Samba to behave differently from Win95 and WinNT
  1962.    * here. They both treat full width ascii characters as case senstive
  1963.    * filenames (ie. they don't do the work we do here).
  1964.    * JRA. 
  1965.    */
  1966.  
  1967.   if(lp_client_code_page() == KANJI_CODEPAGE)
  1968.   {
  1969.     /* Win95 treats full width ascii characters as case sensitive. */
  1970.     while (*s) 
  1971.     {
  1972.       if (is_shift_jis (*s))
  1973.         s += 2;
  1974.       else 
  1975.       {
  1976.         if (*s == c)
  1977.           count++;
  1978.         s++;
  1979.       }
  1980.     }
  1981.   }
  1982.   else
  1983. #endif /* KANJI_WIN95_COMPATIBILITY */
  1984.   {
  1985.     while (*s) 
  1986.     {
  1987.       int skip = skip_multibyte_char( *s );
  1988.       if( skip != 0 )
  1989.         s += skip;
  1990.       else {
  1991.         if (*s == c)
  1992.           count++;
  1993.         s++;
  1994.       }
  1995.     }
  1996.   }
  1997.   return(count);
  1998. }
  1999.  
  2000.  
  2001. /****************************************************************************
  2002.   make a dir struct
  2003. ****************************************************************************/
  2004. void make_dir_struct(char *buf,char *mask,char *fname,unsigned int size,int mode,time_t date)
  2005. {  
  2006.   char *p;
  2007.   pstring mask2;
  2008.  
  2009.   pstrcpy(mask2,mask);
  2010.  
  2011.   if ((mode & aDIR) != 0)
  2012.     size = 0;
  2013.  
  2014.   memset(buf+1,' ',11);
  2015.   if ((p = strchr(mask2,'.')) != NULL)
  2016.     {
  2017.       *p = 0;
  2018.       memcpy(buf+1,mask2,MIN(strlen(mask2),8));
  2019.       memcpy(buf+9,p+1,MIN(strlen(p+1),3));
  2020.       *p = '.';
  2021.     }
  2022.   else
  2023.     memcpy(buf+1,mask2,MIN(strlen(mask2),11));
  2024.  
  2025.   bzero(buf+21,DIR_STRUCT_SIZE-21);
  2026.   CVAL(buf,21) = mode;
  2027.   put_dos_date(buf,22,date);
  2028.   SSVAL(buf,26,size & 0xFFFF);
  2029.   SSVAL(buf,28,size >> 16);
  2030.   StrnCpy(buf+30,fname,12);
  2031.   if (!case_sensitive)
  2032.     strupper(buf+30);
  2033.   DEBUG(8,("put name [%s] into dir struct\n",buf+30));
  2034. }
  2035.  
  2036.  
  2037. /*******************************************************************
  2038. close the low 3 fd's and open dev/null in their place
  2039. ********************************************************************/
  2040. void close_low_fds(void)
  2041. {
  2042.   int fd;
  2043.   int i;
  2044.   close(0); close(1); close(2);
  2045.   /* try and use up these file descriptors, so silly
  2046.      library routines writing to stdout etc won't cause havoc */
  2047.   for (i=0;i<3;i++) {
  2048.     fd = open("/dev/null",O_RDWR,0);
  2049.     if (fd < 0) fd = open("/dev/null",O_WRONLY,0);
  2050.     if (fd < 0) {
  2051.       DEBUG(0,("Can't open /dev/null\n"));
  2052.       return;
  2053.     }
  2054.     if (fd != i) {
  2055.       DEBUG(0,("Didn't get file descriptor %d\n",i));
  2056.       return;
  2057.     }
  2058.   }
  2059. }
  2060.  
  2061. /****************************************************************************
  2062. Set a fd into blocking/nonblocking mode. Uses POSIX O_NONBLOCK if available,
  2063. else
  2064. if SYSV use O_NDELAY
  2065. if BSD use FNDELAY
  2066. ****************************************************************************/
  2067. int set_blocking(int fd, BOOL set)
  2068. {
  2069.   int val;
  2070. #ifdef O_NONBLOCK
  2071. #define FLAG_TO_SET O_NONBLOCK
  2072. #else
  2073. #ifdef SYSV
  2074. #define FLAG_TO_SET O_NDELAY
  2075. #else /* BSD */
  2076. #define FLAG_TO_SET FNDELAY
  2077. #endif
  2078. #endif
  2079.  
  2080.   if((val = fcntl(fd, F_GETFL, 0)) == -1)
  2081.     return -1;
  2082.   if(set) /* Turn blocking on - ie. clear nonblock flag */
  2083.     val &= ~FLAG_TO_SET;
  2084.   else
  2085.     val |= FLAG_TO_SET;
  2086.   return fcntl( fd, F_SETFL, val);
  2087. #undef FLAG_TO_SET
  2088. }
  2089.  
  2090.  
  2091. /****************************************************************************
  2092. write to a socket
  2093. ****************************************************************************/
  2094. int write_socket(int fd,char *buf,int len)
  2095. {
  2096.   int ret=0;
  2097.  
  2098.   if (passive)
  2099.     return(len);
  2100.   DEBUG(6,("write_socket(%d,%d)\n",fd,len));
  2101.   ret = write_data(fd,buf,len);
  2102.       
  2103.   DEBUG(6,("write_socket(%d,%d) wrote %d\n",fd,len,ret));
  2104.   if(ret <= 0)
  2105.     DEBUG(0,("write_socket: Error writing %d bytes to socket %d: ERRNO = %s\n", 
  2106.        len, fd, strerror(errno) ));
  2107.  
  2108.   return(ret);
  2109. }
  2110.  
  2111. /****************************************************************************
  2112. read from a socket
  2113. ****************************************************************************/
  2114. int read_udp_socket(int fd,char *buf,int len)
  2115. {
  2116.   int ret;
  2117.   struct sockaddr_in sock;
  2118.   int socklen;
  2119.   
  2120.   socklen = sizeof(sock);
  2121.   bzero((char *)&sock,socklen);
  2122.   bzero((char *)&lastip,sizeof(lastip));
  2123.   ret = recvfrom(fd,buf,len,0,(struct sockaddr *)&sock,&socklen);
  2124.   if (ret <= 0) {
  2125.     DEBUG(2,("read socket failed. ERRNO=%s\n",strerror(errno)));
  2126.     return(0);
  2127.   }
  2128.  
  2129.   lastip = sock.sin_addr;
  2130.   lastport = ntohs(sock.sin_port);
  2131.  
  2132.   DEBUG(10,("read_udp_socket: lastip %s lastport %d read: %d\n",
  2133.              inet_ntoa(lastip), lastport, ret));
  2134.  
  2135.   return(ret);
  2136. }
  2137.  
  2138. /****************************************************************************
  2139. read data from a device with a timout in msec.
  2140. mincount = if timeout, minimum to read before returning
  2141. maxcount = number to be read.
  2142. ****************************************************************************/
  2143. int read_with_timeout(int fd,char *buf,int mincnt,int maxcnt,long time_out)
  2144. {
  2145.   fd_set fds;
  2146.   int selrtn;
  2147.   int readret;
  2148.   int nread = 0;
  2149.   struct timeval timeout;
  2150.  
  2151.   /* just checking .... */
  2152.   if (maxcnt <= 0) return(0);
  2153.  
  2154.   smb_read_error = 0;
  2155.  
  2156.   /* Blocking read */
  2157.   if (time_out <= 0) {
  2158.     if (mincnt == 0) mincnt = maxcnt;
  2159.  
  2160.     while (nread < mincnt) {
  2161.       readret = read(fd, buf + nread, maxcnt - nread);
  2162.       if (readret == 0) {
  2163.     smb_read_error = READ_EOF;
  2164.     return -1;
  2165.       }
  2166.  
  2167.       if (readret == -1) {
  2168.     smb_read_error = READ_ERROR;
  2169.     return -1;
  2170.       }
  2171.       nread += readret;
  2172.     }
  2173.     return(nread);
  2174.   }
  2175.   
  2176.   /* Most difficult - timeout read */
  2177.   /* If this is ever called on a disk file and 
  2178.      mincnt is greater then the filesize then
  2179.      system performance will suffer severely as 
  2180.      select always return true on disk files */
  2181.  
  2182.   /* Set initial timeout */
  2183.   timeout.tv_sec = time_out / 1000;
  2184.   timeout.tv_usec = 1000 * (time_out % 1000);
  2185.  
  2186.   for (nread=0; nread<mincnt; ) 
  2187.     {      
  2188.       FD_ZERO(&fds);
  2189.       FD_SET(fd,&fds);
  2190.       
  2191.       selrtn = sys_select(&fds,&timeout);
  2192.  
  2193.       /* Check if error */
  2194.       if(selrtn == -1) {
  2195.     /* something is wrong. Maybe the socket is dead? */
  2196.     smb_read_error = READ_ERROR;
  2197.     return -1;
  2198.       }
  2199.       
  2200.       /* Did we timeout ? */
  2201.       if (selrtn == 0) {
  2202.     smb_read_error = READ_TIMEOUT;
  2203.     return -1;
  2204.       }
  2205.       
  2206.       readret = read(fd, buf+nread, maxcnt-nread);
  2207.       if (readret == 0) {
  2208.     /* we got EOF on the file descriptor */
  2209.     smb_read_error = READ_EOF;
  2210.     return -1;
  2211.       }
  2212.  
  2213.       if (readret == -1) {
  2214.     /* the descriptor is probably dead */
  2215.     smb_read_error = READ_ERROR;
  2216.     return -1;
  2217.       }
  2218.       
  2219.       nread += readret;
  2220.     }
  2221.  
  2222.   /* Return the number we got */
  2223.   return(nread);
  2224. }
  2225.  
  2226. /****************************************************************************
  2227. read data from the client. Maxtime is in milliseconds
  2228. ****************************************************************************/
  2229. int read_max_udp(int fd,char *buffer,int bufsize,int maxtime)
  2230. {
  2231.   fd_set fds;
  2232.   int selrtn;
  2233.   int nread;
  2234.   struct timeval timeout;
  2235.  
  2236.   FD_ZERO(&fds);
  2237.   FD_SET(fd,&fds);
  2238.  
  2239.   timeout.tv_sec = maxtime / 1000;
  2240.   timeout.tv_usec = (maxtime % 1000) * 1000;
  2241.  
  2242.   selrtn = sys_select(&fds,maxtime>0?&timeout:NULL);
  2243.  
  2244.   if (!FD_ISSET(fd,&fds))
  2245.     return 0;
  2246.  
  2247.   nread = read_udp_socket(fd, buffer, bufsize);
  2248.  
  2249.   /* return the number got */
  2250.   return(nread);
  2251. }
  2252.  
  2253. /*******************************************************************
  2254. find the difference in milliseconds between two struct timeval
  2255. values
  2256. ********************************************************************/
  2257. int TvalDiff(struct timeval *tvalold,struct timeval *tvalnew)
  2258. {
  2259.   return((tvalnew->tv_sec - tvalold->tv_sec)*1000 + 
  2260.      ((int)tvalnew->tv_usec - (int)tvalold->tv_usec)/1000);     
  2261. }
  2262.  
  2263. /****************************************************************************
  2264. send a keepalive packet (rfc1002)
  2265. ****************************************************************************/
  2266. BOOL send_keepalive(int client)
  2267. {
  2268.   unsigned char buf[4];
  2269.  
  2270.   buf[0] = 0x85;
  2271.   buf[1] = buf[2] = buf[3] = 0;
  2272.  
  2273.   return(write_data(client,(char *)buf,4) == 4);
  2274. }
  2275.  
  2276.  
  2277.  
  2278. /****************************************************************************
  2279.   read data from the client, reading exactly N bytes. 
  2280. ****************************************************************************/
  2281. int read_data(int fd,char *buffer,int N)
  2282. {
  2283.   int  ret;
  2284.   int total=0;  
  2285.  
  2286.   smb_read_error = 0;
  2287.  
  2288.   while (total < N)
  2289.     {
  2290.       ret = read(fd,buffer + total,N - total);
  2291.       if (ret == 0) {
  2292.     smb_read_error = READ_EOF;
  2293.     return 0;
  2294.       }
  2295.       if (ret == -1) {
  2296.     smb_read_error = READ_ERROR;
  2297.     return -1;
  2298.       }
  2299.       total += ret;
  2300.     }
  2301.   return total;
  2302. }
  2303.  
  2304.  
  2305. /****************************************************************************
  2306.   write data to a fd 
  2307. ****************************************************************************/
  2308. int write_data(int fd,char *buffer,int N)
  2309. {
  2310.   int total=0;
  2311.   int ret;
  2312.  
  2313.   while (total < N)
  2314.     {
  2315.       ret = write(fd,buffer + total,N - total);
  2316.  
  2317.       if (ret == -1) return -1;
  2318.       if (ret == 0) return total;
  2319.  
  2320.       total += ret;
  2321.     }
  2322.   return total;
  2323. }
  2324.  
  2325.  
  2326. /****************************************************************************
  2327. transfer some data between two fd's
  2328. ****************************************************************************/
  2329. int transfer_file(int infd,int outfd,int n,char *header,int headlen,int align)
  2330. {
  2331.   static char *buf=NULL;  
  2332.   static int size=0;
  2333.   char *buf1,*abuf;
  2334.   int total = 0;
  2335.  
  2336.   DEBUG(4,("transfer_file %d  (head=%d) called\n",n,headlen));
  2337.  
  2338.   if (size == 0) {
  2339.     size = lp_readsize();
  2340.     size = MAX(size,1024);
  2341.   }
  2342.  
  2343.   while (!buf && size>0) {
  2344.     buf = (char *)Realloc(buf,size+8);
  2345.     if (!buf) size /= 2;
  2346.   }
  2347.  
  2348.   if (!buf) {
  2349.     DEBUG(0,("Can't allocate transfer buffer!\n"));
  2350.     exit(1);
  2351.   }
  2352.  
  2353.   abuf = buf + (align%8);
  2354.  
  2355.   if (header)
  2356.     n += headlen;
  2357.  
  2358.   while (n > 0)
  2359.     {
  2360.       int s = MIN(n,size);
  2361.       int ret,ret2=0;
  2362.  
  2363.       ret = 0;
  2364.  
  2365.       if (header && (headlen >= MIN(s,1024))) {
  2366.     buf1 = header;
  2367.     s = headlen;
  2368.     ret = headlen;
  2369.     headlen = 0;
  2370.     header = NULL;
  2371.       } else {
  2372.     buf1 = abuf;
  2373.       }
  2374.  
  2375.       if (header && headlen > 0)
  2376.     {
  2377.       ret = MIN(headlen,size);
  2378.       memcpy(buf1,header,ret);
  2379.       headlen -= ret;
  2380.       header += ret;
  2381.       if (headlen <= 0) header = NULL;
  2382.     }
  2383.  
  2384.       if (s > ret)
  2385.     ret += read(infd,buf1+ret,s-ret);
  2386.  
  2387.       if (ret > 0)
  2388.     {
  2389.       ret2 = (outfd>=0?write_data(outfd,buf1,ret):ret);
  2390.       if (ret2 > 0) total += ret2;
  2391.       /* if we can't write then dump excess data */
  2392.       if (ret2 != ret)
  2393.         transfer_file(infd,-1,n-(ret+headlen),NULL,0,0);
  2394.     }
  2395.       if (ret <= 0 || ret2 != ret)
  2396.     return(total);
  2397.       n -= ret;
  2398.     }
  2399.   return(total);
  2400. }
  2401.  
  2402.  
  2403. /****************************************************************************
  2404. read 4 bytes of a smb packet and return the smb length of the packet
  2405. store the result in the buffer
  2406. This version of the function will return a length of zero on receiving
  2407. a keepalive packet.
  2408. ****************************************************************************/
  2409. static int read_smb_length_return_keepalive(int fd,char *inbuf,int timeout)
  2410. {
  2411.   int len=0, msg_type;
  2412.   BOOL ok=False;
  2413.  
  2414.   while (!ok)
  2415.     {
  2416.       if (timeout > 0)
  2417.     ok = (read_with_timeout(fd,inbuf,4,4,timeout) == 4);
  2418.       else 
  2419.     ok = (read_data(fd,inbuf,4) == 4);
  2420.  
  2421.       if (!ok)
  2422.     return(-1);
  2423.  
  2424.       len = smb_len(inbuf);
  2425.       msg_type = CVAL(inbuf,0);
  2426.  
  2427.       if (msg_type == 0x85) 
  2428.         DEBUG(5,("Got keepalive packet\n"));
  2429.     }
  2430.  
  2431.   DEBUG(10,("got smb length of %d\n",len));
  2432.  
  2433.   return(len);
  2434. }
  2435.  
  2436. /****************************************************************************
  2437. read 4 bytes of a smb packet and return the smb length of the packet
  2438. store the result in the buffer. This version of the function will
  2439. never return a session keepalive (length of zero).
  2440. ****************************************************************************/
  2441. int read_smb_length(int fd,char *inbuf,int timeout)
  2442. {
  2443.   int len;
  2444.  
  2445.   for(;;)
  2446.   {
  2447.     len = read_smb_length_return_keepalive(fd, inbuf, timeout);
  2448.  
  2449.     if(len < 0)
  2450.       return len;
  2451.  
  2452.     /* Ignore session keepalives. */
  2453.     if(CVAL(inbuf,0) != 0x85)
  2454.       break;
  2455.   }
  2456.  
  2457.   return len;
  2458. }
  2459.  
  2460. /****************************************************************************
  2461.   read an smb from a fd. Note that the buffer *MUST* be of size
  2462.   BUFFER_SIZE+SAFETY_MARGIN.
  2463.   The timeout is in milli seconds. 
  2464.  
  2465.   This function will return on a
  2466.   receipt of a session keepalive packet.
  2467. ****************************************************************************/
  2468. BOOL receive_smb(int fd,char *buffer, int timeout)
  2469. {
  2470.   int len,ret;
  2471.  
  2472.   smb_read_error = 0;
  2473.  
  2474.   bzero(buffer,smb_size + 100);
  2475.  
  2476.   len = read_smb_length_return_keepalive(fd,buffer,timeout);
  2477.   if (len < 0)
  2478.     return(False);
  2479.  
  2480.   if (len > BUFFER_SIZE) {
  2481.     DEBUG(0,("Invalid packet length! (%d bytes).\n",len));
  2482.     if (len > BUFFER_SIZE + (SAFETY_MARGIN/2))
  2483.       exit(1);
  2484.   }
  2485.  
  2486.   if(len > 0) {
  2487.     ret = read_data(fd,buffer+4,len);
  2488.     if (ret != len) {
  2489.       smb_read_error = READ_ERROR;
  2490.       return False;
  2491.     }
  2492.   }
  2493.   return(True);
  2494. }
  2495.  
  2496. /****************************************************************************
  2497.   read an smb from a fd ignoring all keepalive packets. Note that the buffer 
  2498.   *MUST* be of size BUFFER_SIZE+SAFETY_MARGIN.
  2499.   The timeout is in milli seconds
  2500.  
  2501.   This is exactly the same as receive_smb except that it never returns
  2502.   a session keepalive packet (just as receive_smb used to do).
  2503.   receive_smb was changed to return keepalives as the oplock processing means this call
  2504.   should never go into a blocking read.
  2505. ****************************************************************************/
  2506.  
  2507. BOOL client_receive_smb(int fd,char *buffer, int timeout)
  2508. {
  2509.   BOOL ret;
  2510.  
  2511.   for(;;)
  2512.   {
  2513.     ret = receive_smb(fd, buffer, timeout);
  2514.  
  2515.     if(ret == False)
  2516.       return ret;
  2517.  
  2518.     /* Ignore session keepalive packets. */
  2519.     if(CVAL(buffer,0) != 0x85)
  2520.       break;
  2521.   }
  2522.   return ret;
  2523. }
  2524.  
  2525. /****************************************************************************
  2526.   read a message from a udp fd.
  2527. The timeout is in milli seconds
  2528. ****************************************************************************/
  2529. BOOL receive_local_message(int fd, char *buffer, int buffer_len, int timeout)
  2530. {
  2531.   struct sockaddr_in from;
  2532.   int fromlen = sizeof(from);
  2533.   int32 msg_len = 0;
  2534.  
  2535.   smb_read_error = 0;
  2536.  
  2537.   if(timeout != 0)
  2538.   {
  2539.     struct timeval to;
  2540.     fd_set fds;
  2541.     int selrtn;
  2542.  
  2543.     FD_ZERO(&fds);
  2544.     FD_SET(fd,&fds);
  2545.  
  2546.     to.tv_sec = timeout / 1000;
  2547.     to.tv_usec = (timeout % 1000) * 1000;
  2548.  
  2549.     selrtn = sys_select(&fds,&to);
  2550.  
  2551.     /* Check if error */
  2552.     if(selrtn == -1) 
  2553.     {
  2554.       /* something is wrong. Maybe the socket is dead? */
  2555.       smb_read_error = READ_ERROR;
  2556.       return False;
  2557.     } 
  2558.     
  2559.     /* Did we timeout ? */
  2560.     if (selrtn == 0) 
  2561.     {
  2562.       smb_read_error = READ_TIMEOUT;
  2563.       return False;
  2564.     }
  2565.   }
  2566.  
  2567.   /*
  2568.    * Read a loopback udp message.
  2569.    */
  2570.   msg_len = recvfrom(fd, &buffer[UDP_CMD_HEADER_LEN], 
  2571.                      buffer_len - UDP_CMD_HEADER_LEN, 0,
  2572.                      (struct sockaddr *)&from, &fromlen);
  2573.  
  2574.   if(msg_len < 0)
  2575.   {
  2576.     DEBUG(0,("receive_local_message. Error in recvfrom. (%s).\n",strerror(errno)));
  2577.     return False;
  2578.   }
  2579.  
  2580.   /* Validate message length. */
  2581.   if(msg_len > (buffer_len - UDP_CMD_HEADER_LEN))
  2582.   {
  2583.     DEBUG(0,("receive_local_message: invalid msg_len (%d) max can be %d\n",
  2584.               msg_len, 
  2585.               buffer_len  - UDP_CMD_HEADER_LEN));
  2586.     return False;
  2587.   }
  2588.  
  2589.   /* Validate message from address (must be localhost). */
  2590.   if(from.sin_addr.s_addr != htonl(INADDR_LOOPBACK))
  2591.   {
  2592.     DEBUG(0,("receive_local_message: invalid 'from' address \
  2593. (was %x should be 127.0.0.1\n", from.sin_addr.s_addr));
  2594.    return False;
  2595.   }
  2596.  
  2597.   /* Setup the message header */
  2598.   SIVAL(buffer,UDP_CMD_LEN_OFFSET,msg_len);
  2599.   SSVAL(buffer,UDP_CMD_PORT_OFFSET,ntohs(from.sin_port));
  2600.  
  2601.   return True;
  2602. }
  2603.  
  2604. /****************************************************************************
  2605.  structure to hold a linked list of local messages.
  2606.  for processing.
  2607. ****************************************************************************/
  2608.  
  2609. typedef struct _message_list {
  2610.    struct _message_list *msg_next;
  2611.    char *msg_buf;
  2612.    int msg_len;
  2613. } pending_message_list;
  2614.  
  2615. static pending_message_list *smb_msg_head = NULL;
  2616.  
  2617. /****************************************************************************
  2618.  Function to push a linked list of local messages ready
  2619.  for processing.
  2620. ****************************************************************************/
  2621.  
  2622. static BOOL push_local_message(pending_message_list **pml, char *buf, int msg_len)
  2623. {
  2624.   pending_message_list *msg = (pending_message_list *)
  2625.                                malloc(sizeof(pending_message_list));
  2626.  
  2627.   if(msg == NULL)
  2628.   {
  2629.     DEBUG(0,("push_message: malloc fail (1)\n"));
  2630.     return False;
  2631.   }
  2632.  
  2633.   msg->msg_buf = (char *)malloc(msg_len);
  2634.   if(msg->msg_buf == NULL)
  2635.   {
  2636.     DEBUG(0,("push_local_message: malloc fail (2)\n"));
  2637.     free((char *)msg);
  2638.     return False;
  2639.   }
  2640.  
  2641.   memcpy(msg->msg_buf, buf, msg_len);
  2642.   msg->msg_len = msg_len;
  2643.  
  2644.   msg->msg_next = *pml;
  2645.   *pml = msg;
  2646.  
  2647.   return True;
  2648. }
  2649.  
  2650. /****************************************************************************
  2651.  Function to push a linked list of local smb messages ready
  2652.  for processing.
  2653. ****************************************************************************/
  2654.  
  2655. BOOL push_smb_message(char *buf, int msg_len)
  2656. {
  2657.   return push_local_message(&smb_msg_head, buf, msg_len);
  2658. }
  2659.  
  2660. /****************************************************************************
  2661.   Do a select on an two fd's - with timeout. 
  2662.  
  2663.   If a local udp message has been pushed onto the
  2664.   queue (this can only happen during oplock break
  2665.   processing) return this first.
  2666.  
  2667.   If a pending smb message has been pushed onto the
  2668.   queue (this can only happen during oplock break
  2669.   processing) return this next.
  2670.  
  2671.   If the first smbfd is ready then read an smb from it.
  2672.   if the second (loopback UDP) fd is ready then read a message
  2673.   from it and setup the buffer header to identify the length
  2674.   and from address.
  2675.   Returns False on timeout or error.
  2676.   Else returns True.
  2677.  
  2678. The timeout is in milli seconds
  2679. ****************************************************************************/
  2680. BOOL receive_message_or_smb(int smbfd, int oplock_fd, 
  2681.                            char *buffer, int buffer_len, 
  2682.                            int timeout, BOOL *got_smb)
  2683. {
  2684.   fd_set fds;
  2685.   int selrtn;
  2686.   struct timeval to;
  2687.  
  2688.   smb_read_error = 0;
  2689.  
  2690.   *got_smb = False;
  2691.  
  2692.   /*
  2693.    * Check to see if we already have a message on the smb queue.
  2694.    * If so - copy and return it.
  2695.    */
  2696.   
  2697.   if(smb_msg_head)
  2698.   {
  2699.     pending_message_list *msg = smb_msg_head;
  2700.     memcpy(buffer, msg->msg_buf, MIN(buffer_len, msg->msg_len));
  2701.     smb_msg_head = msg->msg_next;
  2702.   
  2703.     /* Free the message we just copied. */
  2704.     free((char *)msg->msg_buf);
  2705.     free((char *)msg);
  2706.     *got_smb = True;
  2707.  
  2708.     DEBUG(5,("receive_message_or_smb: returning queued smb message.\n"));
  2709.     return True;
  2710.   }
  2711.  
  2712.   FD_ZERO(&fds);
  2713.   FD_SET(smbfd,&fds);
  2714.   FD_SET(oplock_fd,&fds);
  2715.  
  2716.   to.tv_sec = timeout / 1000;
  2717.   to.tv_usec = (timeout % 1000) * 1000;
  2718.  
  2719.   selrtn = sys_select(&fds,timeout>0?&to:NULL);
  2720.  
  2721.   /* Check if error */
  2722.   if(selrtn == -1) {
  2723.     /* something is wrong. Maybe the socket is dead? */
  2724.     smb_read_error = READ_ERROR;
  2725.     return False;
  2726.   } 
  2727.     
  2728.   /* Did we timeout ? */
  2729.   if (selrtn == 0) {
  2730.     smb_read_error = READ_TIMEOUT;
  2731.     return False;
  2732.   }
  2733.  
  2734.   if (FD_ISSET(smbfd,&fds))
  2735.   {
  2736.     *got_smb = True;
  2737.     return receive_smb(smbfd, buffer, 0);
  2738.   }
  2739.   else
  2740.   {
  2741.     return receive_local_message(oplock_fd, buffer, buffer_len, 0);
  2742.   }
  2743. }
  2744.  
  2745. /****************************************************************************
  2746.   send an smb to a fd 
  2747. ****************************************************************************/
  2748. BOOL send_smb(int fd,char *buffer)
  2749. {
  2750.   int len;
  2751.   int ret,nwritten=0;
  2752.   len = smb_len(buffer) + 4;
  2753.  
  2754.   while (nwritten < len)
  2755.     {
  2756.       ret = write_socket(fd,buffer+nwritten,len - nwritten);
  2757.       if (ret <= 0)
  2758.     {
  2759.       DEBUG(0,("Error writing %d bytes to client. %d. Exiting\n",len,ret));
  2760.           close_sockets();
  2761.       exit(1);
  2762.     }
  2763.       nwritten += ret;
  2764.     }
  2765.  
  2766.  
  2767.   return True;
  2768. }
  2769.  
  2770.  
  2771. /****************************************************************************
  2772. find a pointer to a netbios name
  2773. ****************************************************************************/
  2774. char *name_ptr(char *buf,int ofs)
  2775. {
  2776.   unsigned char c = *(unsigned char *)(buf+ofs);
  2777.  
  2778.   if ((c & 0xC0) == 0xC0)
  2779.     {
  2780.       uint16 l;
  2781.       char p[2];
  2782.       memcpy(p,buf+ofs,2);
  2783.       p[0] &= ~0xC0;
  2784.       l = RSVAL(p,0);
  2785.       DEBUG(5,("name ptr to pos %d from %d is %s\n",l,ofs,buf+l));
  2786.       return(buf + l);
  2787.     }
  2788.   else
  2789.     return(buf+ofs);
  2790. }  
  2791.  
  2792. /****************************************************************************
  2793. extract a netbios name from a buf
  2794. ****************************************************************************/
  2795. int name_extract(char *buf,int ofs,char *name)
  2796. {
  2797.   char *p = name_ptr(buf,ofs);
  2798.   int d = PTR_DIFF(p,buf+ofs);
  2799.   pstrcpy(name,"");
  2800.   if (d < -50 || d > 50) return(0);
  2801.   return(name_interpret(p,name));
  2802. }
  2803.   
  2804. /****************************************************************************
  2805. return the total storage length of a mangled name
  2806. ****************************************************************************/
  2807. int name_len( char *s )
  2808.   {
  2809.   int len;
  2810.  
  2811.   /* If the two high bits of the byte are set, return 2. */
  2812.   if( 0xC0 == (*(unsigned char *)s & 0xC0) )
  2813.     return(2);
  2814.  
  2815.   /* Add up the length bytes. */
  2816.   for( len = 1; (*s); s += (*s) + 1 )
  2817.     {
  2818.     len += *s + 1;
  2819.     }
  2820.  
  2821.   return( len );
  2822.   } /* name_len */
  2823.  
  2824. /****************************************************************************
  2825. send a single packet to a port on another machine
  2826. ****************************************************************************/
  2827. BOOL send_one_packet(char *buf,int len,struct in_addr ip,int port,int type)
  2828. {
  2829.   BOOL ret;
  2830.   int out_fd;
  2831.   struct sockaddr_in sock_out;
  2832.  
  2833.   if (passive)
  2834.     return(True);
  2835.  
  2836.   /* create a socket to write to */
  2837.   out_fd = socket(AF_INET, type, 0);
  2838.   if (out_fd == -1) 
  2839.     {
  2840.       DEBUG(0,("socket failed"));
  2841.       return False;
  2842.     }
  2843.  
  2844.   /* set the address and port */
  2845.   bzero((char *)&sock_out,sizeof(sock_out));
  2846.   putip((char *)&sock_out.sin_addr,(char *)&ip);
  2847.   sock_out.sin_port = htons( port );
  2848.   sock_out.sin_family = AF_INET;
  2849.   
  2850.   if (DEBUGLEVEL > 0)
  2851.     DEBUG(3,("sending a packet of len %d to (%s) on port %d of type %s\n",
  2852.          len,inet_ntoa(ip),port,type==SOCK_DGRAM?"DGRAM":"STREAM"));
  2853.     
  2854.   /* send it */
  2855.   ret = (sendto(out_fd,buf,len,0,(struct sockaddr *)&sock_out,sizeof(sock_out)) >= 0);
  2856.  
  2857.   if (!ret)
  2858.     DEBUG(0,("Packet send to %s(%d) failed ERRNO=%s\n",
  2859.          inet_ntoa(ip),port,strerror(errno)));
  2860.  
  2861.   close(out_fd);
  2862.   return(ret);
  2863. }
  2864.  
  2865. /*******************************************************************
  2866. sleep for a specified number of milliseconds
  2867. ********************************************************************/
  2868. void msleep(int t)
  2869. {
  2870.   int tdiff=0;
  2871.   struct timeval tval,t1,t2;  
  2872.   fd_set fds;
  2873.  
  2874.   GetTimeOfDay(&t1);
  2875.   GetTimeOfDay(&t2);
  2876.   
  2877.   while (tdiff < t) {
  2878.     tval.tv_sec = (t-tdiff)/1000;
  2879.     tval.tv_usec = 1000*((t-tdiff)%1000);
  2880.  
  2881.     FD_ZERO(&fds);
  2882.     errno = 0;
  2883.     sys_select(&fds,&tval);
  2884.  
  2885.     GetTimeOfDay(&t2);
  2886.     tdiff = TvalDiff(&t1,&t2);
  2887.   }
  2888. }
  2889.  
  2890. /****************************************************************************
  2891. check if a string is part of a list
  2892. ****************************************************************************/
  2893. BOOL in_list(char *s,char *list,BOOL casesensitive)
  2894. {
  2895.   pstring tok;
  2896.   char *p=list;
  2897.  
  2898.   if (!list) return(False);
  2899.  
  2900.   while (next_token(&p,tok,LIST_SEP))
  2901.     {
  2902.       if (casesensitive) {
  2903.     if (strcmp(tok,s) == 0)
  2904.       return(True);
  2905.       } else {
  2906.     if (StrCaseCmp(tok,s) == 0)
  2907.       return(True);
  2908.       }
  2909.     }
  2910.   return(False);
  2911. }
  2912.  
  2913. /* this is used to prevent lots of mallocs of size 1 */
  2914. static char *null_string = NULL;
  2915.  
  2916. /****************************************************************************
  2917. set a string value, allocing the space for the string
  2918. ****************************************************************************/
  2919. BOOL string_init(char **dest,char *src)
  2920. {
  2921.   int l;
  2922.   if (!src)     
  2923.     src = "";
  2924.  
  2925.   l = strlen(src);
  2926.  
  2927.   if (l == 0)
  2928.     {
  2929.       if (!null_string)
  2930.     null_string = (char *)malloc(1);
  2931.  
  2932.       *null_string = 0;
  2933.       *dest = null_string;
  2934.     }
  2935.   else
  2936.     {
  2937.       (*dest) = (char *)malloc(l+1);
  2938.       if ((*dest) == NULL) {
  2939.           DEBUG(0,("Out of memory in string_init\n"));
  2940.           return False;
  2941.       }
  2942.  
  2943.       pstrcpy(*dest,src);
  2944.     }
  2945.   return(True);
  2946. }
  2947.  
  2948. /****************************************************************************
  2949. free a string value
  2950. ****************************************************************************/
  2951. void string_free(char **s)
  2952. {
  2953.   if (!s || !(*s)) return;
  2954.   if (*s == null_string)
  2955.     *s = NULL;
  2956.   if (*s) free(*s);
  2957.   *s = NULL;
  2958. }
  2959.  
  2960. /****************************************************************************
  2961. set a string value, allocing the space for the string, and deallocating any 
  2962. existing space
  2963. ****************************************************************************/
  2964. BOOL string_set(char **dest,char *src)
  2965. {
  2966.   string_free(dest);
  2967.  
  2968.   return(string_init(dest,src));
  2969. }
  2970.  
  2971. /****************************************************************************
  2972. substitute a string for a pattern in another string. Make sure there is 
  2973. enough room!
  2974.  
  2975. This routine looks for pattern in s and replaces it with 
  2976. insert. It may do multiple replacements.
  2977.  
  2978. return True if a substitution was done.
  2979. ****************************************************************************/
  2980. BOOL string_sub(char *s,char *pattern,char *insert)
  2981. {
  2982.   BOOL ret = False;
  2983.   char *p;
  2984.   int ls,lp,li;
  2985.  
  2986.   if (!insert || !pattern || !s) return(False);
  2987.  
  2988.   ls = strlen(s);
  2989.   lp = strlen(pattern);
  2990.   li = strlen(insert);
  2991.  
  2992.   if (!*pattern) return(False);
  2993.  
  2994.   while (lp <= ls && (p = strstr(s,pattern)))
  2995.     {
  2996.       ret = True;
  2997.       memmove(p+li,p+lp,ls + 1 - (PTR_DIFF(p,s) + lp));
  2998.       memcpy(p,insert,li);
  2999.       s = p + li;
  3000.       ls = strlen(s);
  3001.     }
  3002.   return(ret);
  3003. }
  3004.  
  3005. /*********************************************************
  3006. * Recursive routine that is called by unix_mask_match.
  3007. * Does the actual matching. This is the 'original code' 
  3008. * used by the unix matcher.
  3009. *********************************************************/
  3010.  
  3011. static BOOL unix_do_match(char *str, char *regexp, int case_sig)
  3012. {
  3013.   char *p;
  3014.  
  3015.   for( p = regexp; *p && *str; ) {
  3016.     switch(*p) {
  3017.     case '?':
  3018.       str++; p++;
  3019.       break;
  3020.  
  3021.     case '*':
  3022.       /* Look for a character matching 
  3023.        the one after the '*' */
  3024.       p++;
  3025.       if(!*p)
  3026.     return True; /* Automatic match */
  3027.       while(*str) {
  3028.     while(*str && (case_sig ? (*p != *str) : (toupper(*p)!=toupper(*str))))
  3029.       str++;
  3030.     if(unix_do_match(str,p,case_sig))
  3031.       return True;
  3032.     if(!*str)
  3033.       return False;
  3034.     else
  3035.       str++;
  3036.       }
  3037.       return False;
  3038.  
  3039.     default:
  3040.       if(case_sig) {
  3041.     if(*str != *p)
  3042.       return False;
  3043.       } else {
  3044.     if(toupper(*str) != toupper(*p))
  3045.       return False;
  3046.       }
  3047.       str++, p++;
  3048.       break;
  3049.     }
  3050.   }
  3051.   if(!*p && !*str)
  3052.     return True;
  3053.  
  3054.   if (!*p && str[0] == '.' && str[1] == 0)
  3055.     return(True);
  3056.   
  3057.   if (!*str && *p == '?')
  3058.     {
  3059.       while (*p == '?') p++;
  3060.       return(!*p);
  3061.     }
  3062.  
  3063.   if(!*str && (*p == '*' && p[1] == '\0'))
  3064.     return True;
  3065.   return False;
  3066. }
  3067.  
  3068.  
  3069. /*********************************************************
  3070. * Routine to match a given string with a regexp - uses
  3071. * simplified regexp that takes * and ? only. Case can be
  3072. * significant or not.
  3073. * This is the 'original code' used by the unix matcher.
  3074. *********************************************************/
  3075.  
  3076. static BOOL unix_mask_match(char *str, char *regexp, int case_sig,BOOL trans2)
  3077. {
  3078.   char *p;
  3079.   pstring p1, p2;
  3080.   fstring ebase,eext,sbase,sext;
  3081.  
  3082.   BOOL matched;
  3083.  
  3084.   /* Make local copies of str and regexp */
  3085.   StrnCpy(p1,regexp,sizeof(pstring)-1);
  3086.   StrnCpy(p2,str,sizeof(pstring)-1);
  3087.  
  3088.   if (!strchr(p2,'.')) {
  3089.     pstrcat(p2,".");
  3090.   }
  3091.  
  3092.   /* Remove any *? and ** as they are meaningless */
  3093.   for(p = p1; *p; p++)
  3094.     while( *p == '*' && (p[1] == '?' ||p[1] == '*'))
  3095.       (void)pstrcpy( &p[1], &p[2]);
  3096.  
  3097.   if (strequal(p1,"*")) return(True);
  3098.  
  3099.   DEBUG(8,("unix_mask_match str=<%s> regexp=<%s>, case_sig = %d\n", p2, p1, case_sig));
  3100.  
  3101.   if (trans2) {
  3102.     fstrcpy(ebase,p1);
  3103.     fstrcpy(sbase,p2);
  3104.   } else {
  3105.     if ((p=strrchr(p1,'.'))) {
  3106.       *p = 0;
  3107.       fstrcpy(ebase,p1);
  3108.       fstrcpy(eext,p+1);
  3109.     } else {
  3110.       fstrcpy(ebase,p1);
  3111.       eext[0] = 0;
  3112.     }
  3113.  
  3114.   if (!strequal(p2,".") && !strequal(p2,"..") && (p=strrchr(p2,'.'))) {
  3115.     *p = 0;
  3116.     fstrcpy(sbase,p2);
  3117.     fstrcpy(sext,p+1);
  3118.   } else {
  3119.     fstrcpy(sbase,p2);
  3120.     fstrcpy(sext,"");
  3121.   }
  3122.   }
  3123.  
  3124.   matched = unix_do_match(sbase,ebase,case_sig) && 
  3125.     (trans2 || unix_do_match(sext,eext,case_sig));
  3126.  
  3127.   DEBUG(8,("unix_mask_match returning %d\n", matched));
  3128.  
  3129.   return matched;
  3130. }
  3131.  
  3132. /*********************************************************
  3133. * Recursive routine that is called by mask_match.
  3134. * Does the actual matching. Returns True if matched,
  3135. * False if failed.
  3136. *********************************************************/
  3137.  
  3138. BOOL do_match(char *str, char *regexp, int case_sig)
  3139. {
  3140.   char *p;
  3141.  
  3142.   for( p = regexp; *p && *str; ) {
  3143.     switch(*p) {
  3144.     case '?':
  3145.       str++; p++;
  3146.       break;
  3147.  
  3148.     case '*':
  3149.       /* Look for a character matching 
  3150.          the one after the '*' */
  3151.       p++;
  3152.       if(!*p)
  3153.         return True; /* Automatic match */
  3154.       while(*str) {
  3155.         while(*str && (case_sig ? (*p != *str) : (toupper(*p)!=toupper(*str))))
  3156.           str++;
  3157.         /* Now eat all characters that match, as
  3158.            we want the *last* character to match. */
  3159.         while(*str && (case_sig ? (*p == *str) : (toupper(*p)==toupper(*str))))
  3160.           str++;
  3161.         str--; /* We've eaten the match char after the '*' */
  3162.         if(do_match(str,p,case_sig)) {
  3163.           return True;
  3164.         }
  3165.         if(!*str) {
  3166.           return False;
  3167.         } else {
  3168.           str++;
  3169.         }
  3170.       }
  3171.       return False;
  3172.  
  3173.     default:
  3174.       if(case_sig) {
  3175.         if(*str != *p) {
  3176.           return False;
  3177.         }
  3178.       } else {
  3179.         if(toupper(*str) != toupper(*p)) {
  3180.           return False;
  3181.         }
  3182.       }
  3183.       str++, p++;
  3184.       break;
  3185.     }
  3186.   }
  3187.  
  3188.   if(!*p && !*str)
  3189.     return True;
  3190.  
  3191.   if (!*p && str[0] == '.' && str[1] == 0) {
  3192.     return(True);
  3193.   }
  3194.   
  3195.   if (!*str && *p == '?') {
  3196.     while (*p == '?')
  3197.       p++;
  3198.     return(!*p);
  3199.   }
  3200.  
  3201.   if(!*str && (*p == '*' && p[1] == '\0')) {
  3202.     return True;
  3203.   }
  3204.  
  3205.   return False;
  3206. }
  3207.  
  3208.  
  3209. /*********************************************************
  3210. * Routine to match a given string with a regexp - uses
  3211. * simplified regexp that takes * and ? only. Case can be
  3212. * significant or not.
  3213. * The 8.3 handling was rewritten by Ums Harald <Harald.Ums@pro-sieben.de>
  3214. *********************************************************/
  3215.  
  3216. BOOL mask_match(char *str, char *regexp, int case_sig,BOOL trans2)
  3217. {
  3218.   char *p;
  3219.   pstring t_pattern, t_filename, te_pattern, te_filename;
  3220.   fstring ebase,eext,sbase,sext;
  3221.  
  3222.   BOOL matched = False;
  3223.  
  3224.   /* Make local copies of str and regexp */
  3225.   pstrcpy(t_pattern,regexp);
  3226.   pstrcpy(t_filename,str);
  3227.  
  3228. #if 0
  3229.   /* 
  3230.    * Not sure if this is a good idea. JRA.
  3231.    */
  3232.   if(trans2 && is_8_3(t_pattern,False) && is_8_3(t_filename,False))
  3233.     trans2 = False;
  3234. #endif
  3235.  
  3236. #if 0
  3237.   if (!strchr(t_filename,'.')) {
  3238.     pstrcat(t_filename,".");
  3239.   }
  3240. #endif
  3241.  
  3242.   /* Remove any *? and ** as they are meaningless */
  3243.   string_sub(t_pattern, "*?", "*");
  3244.   string_sub(t_pattern, "**", "*");
  3245.  
  3246.   if (strequal(t_pattern,"*"))
  3247.     return(True);
  3248.  
  3249.   DEBUG(8,("mask_match str=<%s> regexp=<%s>, case_sig = %d\n", t_filename, t_pattern, case_sig));
  3250.  
  3251.   if(trans2) {
  3252.     /*
  3253.      * Match each component of the regexp, split up by '.'
  3254.      * characters.
  3255.      */
  3256.     char *fp, *rp, *cp2, *cp1;
  3257.     BOOL last_wcard_was_star = False;
  3258.     int num_path_components, num_regexp_components;
  3259.  
  3260.     pstrcpy(te_pattern,t_pattern);
  3261.     pstrcpy(te_filename,t_filename);
  3262.     /*
  3263.      * Remove multiple "*." patterns.
  3264.      */
  3265.     string_sub(te_pattern, "*.*.", "*.");
  3266.     num_regexp_components = count_chars(te_pattern, '.');
  3267.     num_path_components = count_chars(te_filename, '.');
  3268.  
  3269.     /* 
  3270.      * Check for special 'hack' case of "DIR a*z". - needs to match a.b.c...z
  3271.      */
  3272.     if(num_regexp_components == 0)
  3273.       matched = do_match( te_filename, te_pattern, case_sig);
  3274.     else {
  3275.       for( cp1 = te_pattern, cp2 = te_filename; cp1;) {
  3276.         fp = strchr(cp2, '.');
  3277.         if(fp)
  3278.           *fp = '\0';
  3279.         rp = strchr(cp1, '.');
  3280.         if(rp)
  3281.           *rp = '\0';
  3282.  
  3283.         if(cp1[strlen(cp1)-1] == '*')
  3284.           last_wcard_was_star = True;
  3285.         else
  3286.           last_wcard_was_star = False;
  3287.  
  3288.         if(!do_match(cp2, cp1, case_sig))
  3289.           break;
  3290.  
  3291.         cp1 = rp ? rp + 1 : NULL;
  3292.         cp2 = fp ? fp + 1 : "";
  3293.  
  3294.         if(last_wcard_was_star || ((cp1 != NULL) && (*cp1 == '*'))) {
  3295.           /* Eat the extra path components. */
  3296.           int i;
  3297.  
  3298.           for(i = 0; i < num_path_components - num_regexp_components; i++) {
  3299.             fp = strchr(cp2, '.');
  3300.             if(fp)
  3301.               *fp = '\0';
  3302.  
  3303.             if((cp1 != NULL) && do_match( cp2, cp1, case_sig)) {
  3304.               cp2 = fp ? fp + 1 : "";
  3305.               break;
  3306.             }
  3307.             cp2 = fp ? fp + 1 : "";
  3308.           }
  3309.           num_path_components -= i;
  3310.         }
  3311.       } 
  3312.       if(cp1 == NULL && ((*cp2 == '\0') || last_wcard_was_star))
  3313.         matched = True;
  3314.     }
  3315.   } else {
  3316.  
  3317.     /* -------------------------------------------------
  3318.      * Behaviour of Win95
  3319.      * for 8.3 filenames and 8.3 Wildcards
  3320.      * -------------------------------------------------
  3321.      */
  3322.     if (strequal (t_filename, ".")) {
  3323.       /*
  3324.        *  Patterns:  *.*  *. ?. ?  are valid
  3325.        *
  3326.        */
  3327.       if(strequal(t_pattern, "*.*") || strequal(t_pattern, "*.") ||
  3328.          strequal(t_pattern, "?.") || strequal(t_pattern, "?"))
  3329.         matched = True;
  3330.     } else if (strequal (t_filename, "..")) {
  3331.       /*
  3332.        *  Patterns:  *.*  *. ?. ? *.? are valid
  3333.        *
  3334.        */
  3335.       if(strequal(t_pattern, "*.*") || strequal(t_pattern, "*.") ||
  3336.          strequal(t_pattern, "?.") || strequal(t_pattern, "?") ||
  3337.          strequal(t_pattern, "*.?") || strequal(t_pattern, "?.*"))
  3338.         matched = True;
  3339.     } else {
  3340.  
  3341.       if ((p = strrchr (t_pattern, '.'))) {
  3342.         /*
  3343.          * Wildcard has a suffix.
  3344.          */
  3345.         *p = 0;
  3346.         fstrcpy (ebase, t_pattern);
  3347.         if (p[1]) {
  3348.           fstrcpy (eext, p + 1);
  3349.         } else {
  3350.           /* pattern ends in DOT: treat as if there is no DOT */
  3351.           *eext = 0;
  3352.           if (strequal (ebase, "*"))
  3353.             return (True);
  3354.         }
  3355.       } else {
  3356.         /*
  3357.          * No suffix for wildcard.
  3358.          */
  3359.         fstrcpy (ebase, t_pattern);
  3360.         eext[0] = 0;
  3361.       }
  3362.  
  3363.       p = strrchr (t_filename, '.');
  3364.       if (p && (p[1] == 0)    ) {
  3365.         /*
  3366.          * Filename has an extension of '.' only.
  3367.          */
  3368.         *p = 0; /* nuke dot at end of string */
  3369.         p = 0;  /* and treat it as if there is no extension */
  3370.       }
  3371.  
  3372.       if (p) {
  3373.         /*
  3374.          * Filename has an extension.
  3375.          */
  3376.         *p = 0;
  3377.         fstrcpy (sbase, t_filename);
  3378.         fstrcpy (sext, p + 1);
  3379.         if (*eext) {
  3380.           matched = do_match(sbase, ebase, case_sig)
  3381.                     && do_match(sext, eext, case_sig);
  3382.         } else {
  3383.           /* pattern has no extension */
  3384.           /* Really: match complete filename with pattern ??? means exactly 3 chars */
  3385.           matched = do_match(str, ebase, case_sig);
  3386.         }
  3387.       } else {
  3388.         /* 
  3389.          * Filename has no extension.
  3390.          */
  3391.         fstrcpy (sbase, t_filename);
  3392.         fstrcpy (sext, "");
  3393.         if (*eext) {
  3394.           /* pattern has extension */
  3395.           matched = do_match(sbase, ebase, case_sig)
  3396.                     && do_match(sext, eext, case_sig);
  3397.         } else {
  3398.           matched = do_match(sbase, ebase, case_sig);
  3399. #ifdef EMULATE_WEIRD_W95_MATCHING
  3400.           /*
  3401.            * Even Microsoft has some problems
  3402.            * Behaviour Win95 -> local disk 
  3403.            * is different from Win95 -> smb drive from Nt 4.0
  3404.            * This branch would reflect the Win95 local disk behaviour
  3405.            */
  3406.           if (!matched) {
  3407.             /* a? matches aa and a in w95 */
  3408.             fstrcat (sbase, ".");
  3409.             matched = do_match(sbase, ebase, case_sig);
  3410.           }
  3411. #endif
  3412.         }
  3413.       }
  3414.     }
  3415.   }
  3416.  
  3417.   DEBUG(8,("mask_match returning %d\n", matched));
  3418.  
  3419.   return matched;
  3420. }
  3421.  
  3422.  
  3423. /****************************************************************************
  3424. become a daemon, discarding the controlling terminal
  3425. ****************************************************************************/
  3426. void become_daemon(void)
  3427. {
  3428. #ifndef NO_FORK_DEBUG
  3429.   if (fork())
  3430.     exit(0);
  3431.  
  3432.   /* detach from the terminal */
  3433. #ifdef USE_SETSID
  3434.   setsid();
  3435. #else /* USE_SETSID */
  3436. #ifdef TIOCNOTTY
  3437.   {
  3438.     int i = open("/dev/tty", O_RDWR);
  3439.     if (i >= 0) 
  3440.       {
  3441.     ioctl(i, (int) TIOCNOTTY, (char *)0);      
  3442.     close(i);
  3443.       }
  3444.   }
  3445. #endif /* TIOCNOTTY */
  3446. #endif /* USE_SETSID */
  3447.   /* Close fd's 0,1,2. Needed if started by rsh */
  3448.   close_low_fds();
  3449. #endif /* NO_FORK_DEBUG */
  3450. }
  3451.  
  3452.  
  3453. /****************************************************************************
  3454. put up a yes/no prompt
  3455. ****************************************************************************/
  3456. BOOL yesno(char *p)
  3457. {
  3458.   pstring ans;
  3459.   printf("%s",p);
  3460.  
  3461.   if (!fgets(ans,sizeof(ans)-1,stdin))
  3462.     return(False);
  3463.  
  3464.   if (*ans == 'y' || *ans == 'Y')
  3465.     return(True);
  3466.  
  3467.   return(False);
  3468. }
  3469.  
  3470. /****************************************************************************
  3471. read a line from a file with possible \ continuation chars. 
  3472. Blanks at the start or end of a line are stripped.
  3473. The string will be allocated if s2 is NULL
  3474. ****************************************************************************/
  3475. char *fgets_slash(char *s2,int maxlen,FILE *f)
  3476. {
  3477.   char *s=s2;
  3478.   int len = 0;
  3479.   int c;
  3480.   BOOL start_of_line = True;
  3481.  
  3482.   if (feof(f))
  3483.     return(NULL);
  3484.  
  3485.   if (!s2)
  3486.     {
  3487.       maxlen = MIN(maxlen,8);
  3488.       s = (char *)Realloc(s,maxlen);
  3489.     }
  3490.  
  3491.   if (!s || maxlen < 2) return(NULL);
  3492.  
  3493.   *s = 0;
  3494.  
  3495.   while (len < maxlen-1)
  3496.     {
  3497.       c = getc(f);
  3498.       switch (c)
  3499.     {
  3500.     case '\r':
  3501.       break;
  3502.     case '\n':
  3503.       while (len > 0 && s[len-1] == ' ')
  3504.         {
  3505.           s[--len] = 0;
  3506.         }
  3507.       if (len > 0 && s[len-1] == '\\')
  3508.         {
  3509.           s[--len] = 0;
  3510.           start_of_line = True;
  3511.           break;
  3512.         }
  3513.       return(s);
  3514.     case EOF:
  3515.       if (len <= 0 && !s2) 
  3516.         free(s);
  3517.       return(len>0?s:NULL);
  3518.     case ' ':
  3519.       if (start_of_line)
  3520.         break;
  3521.     default:
  3522.       start_of_line = False;
  3523.       s[len++] = c;
  3524.       s[len] = 0;
  3525.     }
  3526.       if (!s2 && len > maxlen-3)
  3527.     {
  3528.       maxlen *= 2;
  3529.       s = (char *)Realloc(s,maxlen);
  3530.       if (!s) return(NULL);
  3531.     }
  3532.     }
  3533.   return(s);
  3534. }
  3535.  
  3536.  
  3537.  
  3538. /****************************************************************************
  3539. set the length of a file from a filedescriptor.
  3540. Returns 0 on success, -1 on failure.
  3541. ****************************************************************************/
  3542. int set_filelen(int fd, long len)
  3543. {
  3544. /* According to W. R. Stevens advanced UNIX prog. Pure 4.3 BSD cannot
  3545.    extend a file with ftruncate. Provide alternate implementation
  3546.    for this */
  3547.  
  3548. #if FTRUNCATE_CAN_EXTEND
  3549.   return ftruncate(fd, len);
  3550. #else
  3551.   struct stat st;
  3552.   char c = 0;
  3553.   long currpos = lseek(fd, 0L, SEEK_CUR);
  3554.  
  3555.   if(currpos < 0)
  3556.     return -1;
  3557.   /* Do an fstat to see if the file is longer than
  3558.      the requested size (call ftruncate),
  3559.      or shorter, in which case seek to len - 1 and write 1
  3560.      byte of zero */
  3561.   if(fstat(fd, &st)<0)
  3562.     return -1;
  3563.  
  3564. #ifdef S_ISFIFO
  3565.   if (S_ISFIFO(st.st_mode)) return 0;
  3566. #endif
  3567.  
  3568.   if(st.st_size == len)
  3569.     return 0;
  3570.   if(st.st_size > len)
  3571.     return ftruncate(fd, len);
  3572.  
  3573.   if(lseek(fd, len-1, SEEK_SET) != len -1)
  3574.     return -1;
  3575.   if(write(fd, &c, 1)!=1)
  3576.     return -1;
  3577.   /* Seek to where we were */
  3578.   lseek(fd, currpos, SEEK_SET);
  3579.   return 0;
  3580. #endif
  3581. }
  3582.  
  3583.  
  3584. /****************************************************************************
  3585. return the byte checksum of some data
  3586. ****************************************************************************/
  3587. int byte_checksum(char *buf,int len)
  3588. {
  3589.   unsigned char *p = (unsigned char *)buf;
  3590.   int ret = 0;
  3591.   while (len--)
  3592.     ret += *p++;
  3593.   return(ret);
  3594. }
  3595.  
  3596.  
  3597.  
  3598. #ifdef HPUX
  3599. /****************************************************************************
  3600. this is a version of setbuffer() for those machines that only have setvbuf
  3601. ****************************************************************************/
  3602.  void setbuffer(FILE *f,char *buf,int bufsize)
  3603. {
  3604.   setvbuf(f,buf,_IOFBF,bufsize);
  3605. }
  3606. #endif
  3607.  
  3608.  
  3609. /****************************************************************************
  3610. parse out a directory name from a path name. Assumes dos style filenames.
  3611. ****************************************************************************/
  3612. char *dirname_dos(char *path,char *buf)
  3613. {
  3614.   char *p = strrchr(path,'\\');
  3615.  
  3616.   if (!p)
  3617.     pstrcpy(buf,path);
  3618.   else
  3619.     {
  3620.       *p = 0;
  3621.       pstrcpy(buf,path);
  3622.       *p = '\\';
  3623.     }
  3624.  
  3625.   return(buf);
  3626. }
  3627.  
  3628.  
  3629. /****************************************************************************
  3630. parse out a filename from a path name. Assumes dos style filenames.
  3631. ****************************************************************************/
  3632. static char *filename_dos(char *path,char *buf)
  3633. {
  3634.   char *p = strrchr(path,'\\');
  3635.  
  3636.   if (!p)
  3637.     pstrcpy(buf,path);
  3638.   else
  3639.     pstrcpy(buf,p+1);
  3640.  
  3641.   return(buf);
  3642. }
  3643.  
  3644.  
  3645.  
  3646. /****************************************************************************
  3647. expand a pointer to be a particular size
  3648. ****************************************************************************/
  3649. void *Realloc(void *p,int size)
  3650. {
  3651.   void *ret=NULL;
  3652.  
  3653.   if (size == 0) {
  3654.     if (p) free(p);
  3655.     DEBUG(5,("Realloc asked for 0 bytes\n"));
  3656.     return NULL;
  3657.   }
  3658.  
  3659.   if (!p)
  3660.     ret = (void *)malloc(size);
  3661.   else
  3662.     ret = (void *)realloc(p,size);
  3663.  
  3664.   if (!ret)
  3665.     DEBUG(0,("Memory allocation error: failed to expand to %d bytes\n",size));
  3666.  
  3667.   return(ret);
  3668. }
  3669.  
  3670. #ifdef NOSTRDUP
  3671. /****************************************************************************
  3672. duplicate a string
  3673. ****************************************************************************/
  3674.  char *strdup(char *s)
  3675. {
  3676.   char *ret = NULL;
  3677.   int len;
  3678.   if (!s) return(NULL);
  3679.   ret = (char *)malloc((len = strlen(s))+1);
  3680.   if (!ret) return(NULL);
  3681.   safe_strcpy(ret,s,len);
  3682.   return(ret);
  3683. }
  3684. #endif
  3685.  
  3686.  
  3687. /****************************************************************************
  3688.   Signal handler for SIGPIPE (write on a disconnected socket) 
  3689. ****************************************************************************/
  3690. void Abort(void )
  3691. {
  3692.   DEBUG(0,("Probably got SIGPIPE\nExiting\n"));
  3693.   exit(2);
  3694. }
  3695.  
  3696. /****************************************************************************
  3697. get my own name and IP
  3698. ****************************************************************************/
  3699. BOOL get_myname(char *my_name,struct in_addr *ip)
  3700. {
  3701.   struct hostent *hp;
  3702.   pstring hostname;
  3703.  
  3704.   *hostname = 0;
  3705.  
  3706.   /* get my host name */
  3707.   if (gethostname(hostname, MAXHOSTNAMELEN) == -1) 
  3708.     {
  3709.       DEBUG(0,("gethostname failed\n"));
  3710.       return False;
  3711.     } 
  3712.  
  3713.   /* get host info */
  3714.   if ((hp = Get_Hostbyname(hostname)) == 0) 
  3715.     {
  3716.       DEBUG(0,( "Get_Hostbyname: Unknown host %s.\n",hostname));
  3717.       return False;
  3718.     }
  3719.  
  3720.   if (my_name)
  3721.     {
  3722.       /* split off any parts after an initial . */
  3723.       char *p = strchr(hostname,'.');
  3724.       if (p) *p = 0;
  3725.  
  3726.       fstrcpy(my_name,hostname);
  3727.     }
  3728.  
  3729.   if (ip)
  3730.     putip((char *)ip,(char *)hp->h_addr);
  3731.  
  3732.   return(True);
  3733. }
  3734.  
  3735.  
  3736. /****************************************************************************
  3737. true if two IP addresses are equal
  3738. ****************************************************************************/
  3739. BOOL ip_equal(struct in_addr ip1,struct in_addr ip2)
  3740. {
  3741.   uint32 a1,a2;
  3742.   a1 = ntohl(ip1.s_addr);
  3743.   a2 = ntohl(ip2.s_addr);
  3744.   return(a1 == a2);
  3745. }
  3746.  
  3747.  
  3748. /****************************************************************************
  3749. open a socket of the specified type, port and address for incoming data
  3750. ****************************************************************************/
  3751. int open_socket_in(int type, int port, int dlevel,uint32 socket_addr)
  3752. {
  3753.   struct hostent *hp;
  3754.   struct sockaddr_in sock;
  3755.   pstring host_name;
  3756.   int res;
  3757.  
  3758.   /* get my host name */
  3759.   if (gethostname(host_name, MAXHOSTNAMELEN) == -1) 
  3760.     { DEBUG(0,("gethostname failed\n")); return -1; } 
  3761.  
  3762.   /* get host info */
  3763.   if ((hp = Get_Hostbyname(host_name)) == 0) 
  3764.     {
  3765.       DEBUG(0,( "Get_Hostbyname: Unknown host. %s\n",host_name));
  3766.       return -1;
  3767.     }
  3768.   
  3769.   bzero((char *)&sock,sizeof(sock));
  3770.   memcpy((char *)&sock.sin_addr,(char *)hp->h_addr, hp->h_length);
  3771. #if defined(__FreeBSD__) || defined(NETBSD) || defined(__OpenBSD__) /* XXX not the right ifdef */
  3772.   sock.sin_len = sizeof(sock);
  3773. #endif
  3774.   sock.sin_port = htons( port );
  3775.   sock.sin_family = hp->h_addrtype;
  3776.   sock.sin_addr.s_addr = socket_addr;
  3777.   res = socket(hp->h_addrtype, type, 0);
  3778.   if (res == -1) 
  3779.     { DEBUG(0,("socket failed\n")); return -1; }
  3780.  
  3781.   {
  3782.     int one=1;
  3783.     setsockopt(res,SOL_SOCKET,SO_REUSEADDR,(char *)&one,sizeof(one));
  3784.   }
  3785.  
  3786.   /* now we've got a socket - we need to bind it */
  3787.   if (bind(res, (struct sockaddr * ) &sock,sizeof(sock)) < 0) 
  3788.     { 
  3789.       if (port) {
  3790.     if (port == SMB_PORT || port == NMB_PORT)
  3791.       DEBUG(dlevel,("bind failed on port %d socket_addr=%s (%s)\n",
  3792.             port,inet_ntoa(sock.sin_addr),strerror(errno))); 
  3793.     close(res); 
  3794.  
  3795.     if (dlevel > 0 && port < 1000)
  3796.       port = 7999;
  3797.  
  3798.     if (port >= 1000 && port < 9000)
  3799.       return(open_socket_in(type,port+1,dlevel,socket_addr));
  3800.       }
  3801.  
  3802.       return(-1); 
  3803.     }
  3804.   DEBUG(3,("bind succeeded on port %d\n",port));
  3805.  
  3806.   return res;
  3807. }
  3808.  
  3809.  
  3810. /****************************************************************************
  3811.   create an outgoing socket
  3812.   **************************************************************************/
  3813. int open_socket_out(int type, struct in_addr *addr, int port ,int timeout)
  3814. {
  3815.   struct sockaddr_in sock_out;
  3816.   int res,ret;
  3817.   int connect_loop = 250; /* 250 milliseconds */
  3818.   int loops = (timeout * 1000) / connect_loop;
  3819.  
  3820.   /* create a socket to write to */
  3821.   res = socket(PF_INET, type, 0);
  3822.   if (res == -1) 
  3823.     { DEBUG(0,("socket error\n")); return -1; }
  3824.  
  3825.   if (type != SOCK_STREAM) return(res);
  3826.   
  3827.   bzero((char *)&sock_out,sizeof(sock_out));
  3828.   putip((char *)&sock_out.sin_addr,(char *)addr);
  3829.   
  3830.   sock_out.sin_port = htons( port );
  3831.   sock_out.sin_family = PF_INET;
  3832.  
  3833.   /* set it non-blocking */
  3834.   set_blocking(res,False);
  3835.  
  3836.   DEBUG(3,("Connecting to %s at port %d\n",inet_ntoa(*addr),port));
  3837.   
  3838.   /* and connect it to the destination */
  3839. connect_again:
  3840.   ret = connect(res,(struct sockaddr *)&sock_out,sizeof(sock_out));
  3841.  
  3842.   /* Some systems return EAGAIN when they mean EINPROGRESS */
  3843.   if (ret < 0 && (errno == EINPROGRESS || errno == EALREADY ||
  3844.         errno == EAGAIN) && loops--) {
  3845.     msleep(connect_loop);
  3846.     goto connect_again;
  3847.   }
  3848.  
  3849.   if (ret < 0 && (errno == EINPROGRESS || errno == EALREADY ||
  3850.          errno == EAGAIN)) {
  3851.       DEBUG(1,("timeout connecting to %s:%d\n",inet_ntoa(*addr),port));
  3852.       close(res);
  3853.       return -1;
  3854.   }
  3855.  
  3856. #ifdef EISCONN
  3857.   if (ret < 0 && errno == EISCONN) {
  3858.     errno = 0;
  3859.     ret = 0;
  3860.   }
  3861. #endif
  3862.  
  3863.   if (ret < 0) {
  3864.     DEBUG(1,("error connecting to %s:%d (%s)\n",
  3865.          inet_ntoa(*addr),port,strerror(errno)));
  3866.     close(res);
  3867.     return -1;
  3868.   }
  3869.  
  3870.   /* set it blocking again */
  3871.   set_blocking(res,True);
  3872.  
  3873.   return res;
  3874. }
  3875.  
  3876.  
  3877. /****************************************************************************
  3878. interpret a protocol description string, with a default
  3879. ****************************************************************************/
  3880. int interpret_protocol(char *str,int def)
  3881. {
  3882.   if (strequal(str,"NT1"))
  3883.     return(PROTOCOL_NT1);
  3884.   if (strequal(str,"LANMAN2"))
  3885.     return(PROTOCOL_LANMAN2);
  3886.   if (strequal(str,"LANMAN1"))
  3887.     return(PROTOCOL_LANMAN1);
  3888.   if (strequal(str,"CORE"))
  3889.     return(PROTOCOL_CORE);
  3890.   if (strequal(str,"COREPLUS"))
  3891.     return(PROTOCOL_COREPLUS);
  3892.   if (strequal(str,"CORE+"))
  3893.     return(PROTOCOL_COREPLUS);
  3894.   
  3895.   DEBUG(0,("Unrecognised protocol level %s\n",str));
  3896.   
  3897.   return(def);
  3898. }
  3899.  
  3900. /****************************************************************************
  3901. interpret a security level
  3902. ****************************************************************************/
  3903. int interpret_security(char *str,int def)
  3904. {
  3905.   if (strequal(str,"SERVER"))
  3906.     return(SEC_SERVER);
  3907.   if (strequal(str,"USER"))
  3908.     return(SEC_USER);
  3909.   if (strequal(str,"SHARE"))
  3910.     return(SEC_SHARE);
  3911.   
  3912.   DEBUG(0,("Unrecognised security level %s\n",str));
  3913.   
  3914.   return(def);
  3915. }
  3916.  
  3917.  
  3918. /****************************************************************************
  3919. interpret an internet address or name into an IP address in 4 byte form
  3920. ****************************************************************************/
  3921. uint32 interpret_addr(char *str)
  3922. {
  3923.   struct hostent *hp;
  3924.   uint32 res;
  3925.   int i;
  3926.   BOOL pure_address = True;
  3927.  
  3928.   if (strcmp(str,"0.0.0.0") == 0) return(0);
  3929.   if (strcmp(str,"255.255.255.255") == 0) return(0xFFFFFFFF);
  3930.  
  3931.   for (i=0; pure_address && str[i]; i++)
  3932.     if (!(isdigit(str[i]) || str[i] == '.')) 
  3933.       pure_address = False;
  3934.  
  3935.   /* if it's in the form of an IP address then get the lib to interpret it */
  3936.   if (pure_address) {
  3937.     res = inet_addr(str);
  3938.   } else {
  3939.     /* otherwise assume it's a network name of some sort and use 
  3940.        Get_Hostbyname */
  3941.     if ((hp = Get_Hostbyname(str)) == 0) {
  3942.       DEBUG(3,("Get_Hostbyname: Unknown host. %s\n",str));
  3943.       return 0;
  3944.     }
  3945.     if(hp->h_addr == NULL) {
  3946.       DEBUG(3,("Get_Hostbyname: host address is invalid for host %s.\n",str));
  3947.       return 0;
  3948.     }
  3949.     putip((char *)&res,(char *)hp->h_addr);
  3950.   }
  3951.  
  3952.   if (res == (uint32)-1) return(0);
  3953.  
  3954.   return(res);
  3955. }
  3956.  
  3957. /*******************************************************************
  3958.   a convenient addition to interpret_addr()
  3959.   ******************************************************************/
  3960. struct in_addr *interpret_addr2(char *str)
  3961. {
  3962.   static struct in_addr ret;
  3963.   uint32 a = interpret_addr(str);
  3964.   ret.s_addr = a;
  3965.   return(&ret);
  3966. }
  3967.  
  3968. /*******************************************************************
  3969.   check if an IP is the 0.0.0.0
  3970.   ******************************************************************/
  3971. BOOL zero_ip(struct in_addr ip)
  3972. {
  3973.   uint32 a;
  3974.   putip((char *)&a,(char *)&ip);
  3975.   return(a == 0);
  3976. }
  3977.  
  3978.  
  3979. /*******************************************************************
  3980.  matchname - determine if host name matches IP address 
  3981.  ******************************************************************/
  3982. static BOOL matchname(char *remotehost,struct in_addr  addr)
  3983. {
  3984.   struct hostent *hp;
  3985.   int     i;
  3986.   
  3987.   if ((hp = Get_Hostbyname(remotehost)) == 0) {
  3988.     DEBUG(0,("Get_Hostbyname(%s): lookup failure", remotehost));
  3989.     return False;
  3990.   } 
  3991.  
  3992.   /*
  3993.    * Make sure that gethostbyname() returns the "correct" host name.
  3994.    * Unfortunately, gethostbyname("localhost") sometimes yields
  3995.    * "localhost.domain". Since the latter host name comes from the
  3996.    * local DNS, we just have to trust it (all bets are off if the local
  3997.    * DNS is perverted). We always check the address list, though.
  3998.    */
  3999.   
  4000.   if (strcasecmp(remotehost, hp->h_name)
  4001.       && strcasecmp(remotehost, "localhost")) {
  4002.     DEBUG(0,("host name/name mismatch: %s != %s",
  4003.          remotehost, hp->h_name));
  4004.     return False;
  4005.   }
  4006.     
  4007.   /* Look up the host address in the address list we just got. */
  4008.   for (i = 0; hp->h_addr_list[i]; i++) {
  4009.     if (memcmp(hp->h_addr_list[i], (caddr_t) & addr, sizeof(addr)) == 0)
  4010.       return True;
  4011.   }
  4012.  
  4013.   /*
  4014.    * The host name does not map to the original host address. Perhaps
  4015.    * someone has compromised a name server. More likely someone botched
  4016.    * it, but that could be dangerous, too.
  4017.    */
  4018.   
  4019.   DEBUG(0,("host name/address mismatch: %s != %s",
  4020.        inet_ntoa(addr), hp->h_name));
  4021.   return False;
  4022. }
  4023.  
  4024. /*******************************************************************
  4025.  Reset the 'done' variables so after a client process is created
  4026.  from a fork call these calls will be re-done. This should be
  4027.  expanded if more variables need reseting.
  4028.  ******************************************************************/
  4029.  
  4030. static BOOL global_client_name_done = False;
  4031. static BOOL global_client_addr_done = False;
  4032.  
  4033. void reset_globals_after_fork(void)
  4034. {
  4035.   global_client_name_done = False;
  4036.   global_client_addr_done = False;
  4037. }
  4038.  
  4039. /*******************************************************************
  4040.  return the DNS name of the client 
  4041.  ******************************************************************/
  4042. char *client_name(void)
  4043. {
  4044.   struct sockaddr sa;
  4045.   struct sockaddr_in *sockin = (struct sockaddr_in *) (&sa);
  4046.   int     length = sizeof(sa);
  4047.   static pstring name_buf;
  4048.   struct hostent *hp;
  4049.  
  4050.   if (global_client_name_done) 
  4051.     return name_buf;
  4052.  
  4053.   pstrcpy(name_buf,"UNKNOWN");
  4054.  
  4055.   if (Client == -1) {
  4056.       return name_buf;
  4057.   }
  4058.  
  4059.   if (getpeername(Client, &sa, &length) < 0) {
  4060.     DEBUG(0,("getpeername failed\n"));
  4061.     return name_buf;
  4062.   }
  4063.  
  4064.   /* Look up the remote host name. */
  4065.   if ((hp = gethostbyaddr((char *) &sockin->sin_addr,
  4066.               sizeof(sockin->sin_addr),
  4067.               AF_INET)) == 0) {
  4068.     DEBUG(1,("Gethostbyaddr failed for %s\n",client_addr()));
  4069.     StrnCpy(name_buf,client_addr(),sizeof(name_buf) - 1);
  4070.   } else {
  4071.     StrnCpy(name_buf,(char *)hp->h_name,sizeof(name_buf) - 1);
  4072.     if (!matchname(name_buf, sockin->sin_addr)) {
  4073.       DEBUG(0,("Matchname failed on %s %s\n",name_buf,client_addr()));
  4074.       pstrcpy(name_buf,"UNKNOWN");
  4075.     }
  4076.   }
  4077.   global_client_name_done = True;
  4078.   return name_buf;
  4079. }
  4080.  
  4081. /*******************************************************************
  4082.  return the IP addr of the client as a string 
  4083.  ******************************************************************/
  4084. char *client_addr(void)
  4085. {
  4086.   struct sockaddr sa;
  4087.   struct sockaddr_in *sockin = (struct sockaddr_in *) (&sa);
  4088.   int     length = sizeof(sa);
  4089.   static fstring addr_buf;
  4090.  
  4091.   if (global_client_addr_done) 
  4092.     return addr_buf;
  4093.  
  4094.   fstrcpy(addr_buf,"0.0.0.0");
  4095.  
  4096.   if (Client == -1) {
  4097.       return addr_buf;
  4098.   }
  4099.  
  4100.   if (getpeername(Client, &sa, &length) < 0) {
  4101.     DEBUG(0,("getpeername failed\n"));
  4102.     return addr_buf;
  4103.   }
  4104.  
  4105.   fstrcpy(addr_buf,(char *)inet_ntoa(sockin->sin_addr));
  4106.  
  4107.   global_client_addr_done = True;
  4108.   return addr_buf;
  4109. }
  4110.  
  4111. #if (defined(NETGROUP) && defined(AUTOMOUNT))
  4112. /******************************************************************
  4113.  Remove any mount options such as -rsize=2048,wsize=2048 etc.
  4114.  Based on a fix from <Thomas.Hepper@icem.de>.
  4115. *******************************************************************/
  4116.   
  4117. static void strip_mount_options( pstring *str)
  4118. {  
  4119.   if (**str == '-')
  4120.   {
  4121.     char *p = *str;
  4122.     while(*p && !isspace(*p))
  4123.       p++;
  4124.     while(*p && isspace(*p))
  4125.       p++;
  4126.     if(*p) {
  4127.       pstring tmp_str;
  4128.    
  4129.       pstrcpy(tmp_str, p);
  4130.       pstrcpy(*str, tmp_str); 
  4131.     }
  4132.   }
  4133. }  
  4134.  
  4135. /*******************************************************************
  4136.  Patch from jkf@soton.ac.uk
  4137.  Split Luke's automount_server into YP lookup and string splitter
  4138.  so can easily implement automount_path(). 
  4139.  As we may end up doing both, cache the last YP result. 
  4140. *******************************************************************/
  4141.  
  4142. #ifdef NISPLUS
  4143. static char *automount_lookup(char *user_name)
  4144. {
  4145.   static fstring last_key = "";
  4146.   static pstring last_value = "";
  4147.  
  4148.   char *nis_map = (char *)lp_nis_home_map_name();
  4149.  
  4150.   char nis_domain[NIS_MAXNAMELEN + 1];
  4151.   char buffer[NIS_MAXATTRVAL + 1];
  4152.   nis_result *result;
  4153.   nis_object *object;
  4154.   entry_obj  *entry;
  4155.  
  4156.   strncpy(nis_domain, (char *)nis_local_directory(), NIS_MAXNAMELEN);
  4157.   nis_domain[NIS_MAXNAMELEN] = '\0';
  4158.  
  4159.   DEBUG(5, ("NIS+ Domain: %s\n", nis_domain));
  4160.  
  4161.   if (strcmp(user_name, last_key))
  4162.   {
  4163.     slprintf(buffer, sizeof(buffer)-1, "[%s=%s]%s.%s", "key", user_name, nis_map, nis_domain);
  4164.     DEBUG(5, ("NIS+ querystring: %s\n", buffer));
  4165.  
  4166.     if (result = nis_list(buffer, RETURN_RESULT, NULL, NULL))
  4167.     {
  4168.        if (result->status != NIS_SUCCESS)
  4169.       {
  4170.         DEBUG(3, ("NIS+ query failed: %s\n", nis_sperrno(result->status)));
  4171.         fstrcpy(last_key, ""); pstrcpy(last_value, "");
  4172.       }
  4173.       else
  4174.       {
  4175.         object = result->objects.objects_val;
  4176.         if (object->zo_data.zo_type == ENTRY_OBJ)
  4177.         {
  4178.            entry = &object->zo_data.objdata_u.en_data;
  4179.            DEBUG(5, ("NIS+ entry type: %s\n", entry->en_type));
  4180.            DEBUG(3, ("NIS+ result: %s\n", entry->en_cols.en_cols_val[1].ec_value.ec_value_val));
  4181.  
  4182.            pstrcpy(last_value, entry->en_cols.en_cols_val[1].ec_value.ec_value_val);
  4183.            string_sub(last_value, "&", user_name);
  4184.            fstrcpy(last_key, user_name);
  4185.         }
  4186.       }
  4187.     }
  4188.     nis_freeresult(result);
  4189.   }
  4190.  
  4191.   strip_mount_options(&last_value);
  4192.  
  4193.   DEBUG(4, ("NIS+ Lookup: %s resulted in %s\n", user_name, last_value));
  4194.   return last_value;
  4195. }
  4196. #else /* NISPLUS */
  4197. static char *automount_lookup(char *user_name)
  4198. {
  4199.   static fstring last_key = "";
  4200.   static pstring last_value = "";
  4201.  
  4202.   int nis_error;        /* returned by yp all functions */
  4203.   char *nis_result;     /* yp_match inits this */
  4204.   int nis_result_len;  /* and set this */
  4205.   char *nis_domain;     /* yp_get_default_domain inits this */
  4206.   char *nis_map = (char *)lp_nis_home_map_name();
  4207.  
  4208.   if ((nis_error = yp_get_default_domain(&nis_domain)) != 0)
  4209.   {
  4210.     DEBUG(3, ("YP Error: %s\n", yperr_string(nis_error)));
  4211.     return last_value;
  4212.   }
  4213.  
  4214.   DEBUG(5, ("NIS Domain: %s\n", nis_domain));
  4215.  
  4216.   if (!strcmp(user_name, last_key))
  4217.   {
  4218.     nis_result = last_value;
  4219.     nis_result_len = strlen(last_value);
  4220.     nis_error = 0;
  4221.   }
  4222.   else
  4223.   {
  4224.     if ((nis_error = yp_match(nis_domain, nis_map,
  4225.                               user_name, strlen(user_name),
  4226.                               &nis_result, &nis_result_len)) != 0)
  4227.     {
  4228.       DEBUG(3, ("YP Error: \"%s\" while looking up \"%s\" in map \"%s\"\n", 
  4229.                yperr_string(nis_error), user_name, nis_map));
  4230.     }
  4231.     if (!nis_error && nis_result_len >= sizeof(pstring))
  4232.     {
  4233.       nis_result_len = sizeof(pstring)-1;
  4234.     }
  4235.     fstrcpy(last_key, user_name);
  4236.     strncpy(last_value, nis_result, nis_result_len);
  4237.     last_value[nis_result_len] = '\0';
  4238.   }
  4239.  
  4240.   strip_mount_options(&last_value);
  4241.  
  4242.   DEBUG(4, ("YP Lookup: %s resulted in %s\n", user_name, last_value));
  4243.   return last_value;
  4244. }
  4245. #endif /* NISPLUS */
  4246. #endif
  4247.  
  4248. /*******************************************************************
  4249.  Patch from jkf@soton.ac.uk
  4250.  This is Luke's original function with the NIS lookup code
  4251.  moved out to a separate function.
  4252. *******************************************************************/
  4253.  
  4254. char *automount_server(char *user_name)
  4255. {
  4256.     static pstring server_name;
  4257.  
  4258. #if (defined(NETGROUP) && defined (AUTOMOUNT))
  4259.     int home_server_len;
  4260.  
  4261.     /* set to default of local machine */
  4262.     pstrcpy(server_name, local_machine);
  4263.  
  4264.     if (lp_nis_home_map())
  4265.     {
  4266.         char *automount_value = automount_lookup(user_name);
  4267.         home_server_len = strcspn(automount_value,":");
  4268.         DEBUG(5, ("NIS lookup succeeded.  Home server length: %d\n",home_server_len));
  4269.         if (home_server_len > sizeof(pstring))
  4270.         {
  4271.             home_server_len = sizeof(pstring);
  4272.         }
  4273.         strncpy(server_name, automount_value, home_server_len);
  4274.                 server_name[home_server_len] = '\0';
  4275.     }
  4276. #else
  4277.     /* use the local machine name instead of the auto-map server */
  4278.     pstrcpy(server_name, local_machine);
  4279. #endif
  4280.  
  4281.     DEBUG(4,("Home server: %s\n", server_name));
  4282.  
  4283.     return server_name;
  4284. }
  4285.  
  4286. /*******************************************************************
  4287.  Patch from jkf@soton.ac.uk
  4288.  Added this to implement %p (NIS auto-map version of %H)
  4289. *******************************************************************/
  4290.  
  4291. char *automount_path(char *user_name)
  4292. {
  4293.     static pstring server_path;
  4294.  
  4295. #if (defined(NETGROUP) && defined (AUTOMOUNT))
  4296.     char *home_path_start;
  4297.  
  4298.     /* set to default of no string */
  4299.     server_path[0] = 0;
  4300.  
  4301.     if (lp_nis_home_map())
  4302.     {
  4303.         char *automount_value = automount_lookup(user_name);
  4304.         home_path_start = strchr(automount_value,':');
  4305.         if (home_path_start != NULL)
  4306.         {
  4307.           DEBUG(5, ("NIS lookup succeeded.  Home path is: %s\n",
  4308.                 home_path_start?(home_path_start+1):""));
  4309.           pstrcpy(server_path, home_path_start+1);
  4310.         }
  4311.     }
  4312. #else
  4313.     /* use the passwd entry instead of the auto-map server entry */
  4314.     /* pstrcpy() copes with get_home_dir() returning NULL */
  4315.     pstrcpy(server_path, get_home_dir(user_name));
  4316. #endif
  4317.  
  4318.     DEBUG(4,("Home server path: %s\n", server_path));
  4319.  
  4320.     return server_path;
  4321. }
  4322.  
  4323.  
  4324. /*******************************************************************
  4325. sub strings with useful parameters
  4326. Rewritten by Stefaan A Eeckels <Stefaan.Eeckels@ecc.lu> and
  4327. Paul Rippin <pr3245@nopc.eurostat.cec.be>
  4328. ********************************************************************/
  4329. void standard_sub_basic(char *str)
  4330. {
  4331.     char *s, *p;
  4332.     char pidstr[10];
  4333.         struct passwd *pass;
  4334.         char *username = sam_logon_in_ssb ? samlogon_user : sesssetup_user;
  4335.  
  4336.     for (s = str ; s && *s && (p = strchr(s,'%')); s = p )
  4337.     {
  4338.         switch (*(p+1))
  4339.         {
  4340.                         case 'G' :
  4341.                         {
  4342.                                 if ((pass = Get_Pwnam(username,False))!=NULL)
  4343.                                 {
  4344.                                         string_sub(p,"%G",gidtoname(pass->pw_gid));
  4345.                                 }
  4346.                                 else
  4347.                                 {
  4348.                                         p += 2;
  4349.                                 }
  4350.                                 break;
  4351.                         }
  4352.                         case 'N' : string_sub(p,"%N", automount_server(username)); break;
  4353.             case 'I' : string_sub(p,"%I", client_addr()); break;
  4354.             case 'L' : string_sub(p,"%L", local_machine); break;
  4355.             case 'M' : string_sub(p,"%M", client_name()); break;
  4356.             case 'R' : string_sub(p,"%R", remote_proto); break;
  4357.             case 'T' : string_sub(p,"%T", timestring()); break;
  4358.             case 'a' : string_sub(p,"%a", remote_arch); break;
  4359.                         case 'U' : string_sub(p,"%U", username); break;
  4360.             case 'd' :
  4361.             {
  4362.                 slprintf(pidstr,sizeof(pidstr)-1,"%d",(int)getpid());
  4363.                 string_sub(p,"%d", pidstr);
  4364.                 break;
  4365.             }
  4366.             case 'h' : string_sub(p,"%h", myhostname); break;
  4367.             case 'm' : string_sub(p,"%m", remote_machine); break;
  4368.             case 'v' : string_sub(p,"%v", VERSION); break;
  4369.                         case '$' : /* Expand environment variables */
  4370.                         {
  4371.                           /* Contributed by Branko Cibej <branko.cibej@hermes.si> */
  4372.                           fstring envname;
  4373.                           char *envval;
  4374.                           char *q, *r;
  4375.                           int copylen;
  4376.  
  4377.                           if (*(p+2) != '(') { p+=2; break; }
  4378.                           if ((q = strchr(p,')')) == NULL)
  4379.                           {
  4380.                             DEBUG(0,("standard_sub_basic: Unterminated environment \
  4381. variable [%s]\n", p));
  4382.                             p+=2; break;
  4383.                           }
  4384.  
  4385.                           r = p+3;
  4386.                           copylen = MIN((q-r),(sizeof(envname)-1));
  4387.                           strncpy(envname,r,copylen);
  4388.                           envname[copylen] = '\0';
  4389.                           if ((envval = getenv(envname)) == NULL)
  4390.                           {
  4391.                             DEBUG(0,("standard_sub_basic: Environment variable [%s] not set\n",
  4392.                                      envname));
  4393.                             p+=2; break;
  4394.                           }
  4395.                           copylen = MIN((q+1-p),(sizeof(envname)-1));
  4396.                           strncpy(envname,p,copylen);
  4397.                           envname[copylen] = '\0';
  4398.                           string_sub(p,envname,envval);
  4399.                           break;
  4400.                         }
  4401.             case '\0': p++; break; /* don't run off end if last character is % */
  4402.             default  : p+=2; break;
  4403.         }
  4404.     }
  4405.     return;
  4406. }
  4407.  
  4408. /*******************************************************************
  4409. are two IPs on the same subnet?
  4410. ********************************************************************/
  4411. BOOL same_net(struct in_addr ip1,struct in_addr ip2,struct in_addr mask)
  4412. {
  4413.   uint32 net1,net2,nmask;
  4414.  
  4415.   nmask = ntohl(mask.s_addr);
  4416.   net1  = ntohl(ip1.s_addr);
  4417.   net2  = ntohl(ip2.s_addr);
  4418.             
  4419.   return((net1 & nmask) == (net2 & nmask));
  4420. }
  4421.  
  4422.  
  4423. /*******************************************************************
  4424. write a string in unicoode format
  4425. ********************************************************************/
  4426. int PutUniCode(char *dst,char *src)
  4427. {
  4428.   int ret = 0;
  4429.   while (*src) {
  4430.     dst[ret++] = src[0];
  4431.     dst[ret++] = 0;    
  4432.     src++;
  4433.   }
  4434.   dst[ret++]=0;
  4435.   dst[ret++]=0;
  4436.   return(ret);
  4437. }
  4438.  
  4439. /****************************************************************************
  4440. a wrapper for gethostbyname() that tries with all lower and all upper case 
  4441. if the initial name fails
  4442. ****************************************************************************/
  4443. struct hostent *Get_Hostbyname(char *name)
  4444. {
  4445.   char *name2 = strdup(name);
  4446.   struct hostent *ret;
  4447.  
  4448.   if (!name2)
  4449.     {
  4450.       DEBUG(0,("Memory allocation error in Get_Hostbyname! panic\n"));
  4451.       exit(0);
  4452.     }
  4453.  
  4454.   /*
  4455.    * This next test is redundent and causes some systems (with
  4456.    * broken isalnum() calls) problems.
  4457.    * JRA.
  4458.    */
  4459.  
  4460. #if 0
  4461.   if (!isalnum(*name2))
  4462.     {
  4463.       free(name2);
  4464.       return(NULL);
  4465.     }
  4466. #endif /* 0 */
  4467.  
  4468.   ret = sys_gethostbyname(name2);
  4469.   if (ret != NULL)
  4470.     {
  4471.       free(name2);
  4472.       return(ret);
  4473.     }
  4474.  
  4475.   /* try with all lowercase */
  4476.   strlower(name2);
  4477.   ret = sys_gethostbyname(name2);
  4478.   if (ret != NULL)
  4479.     {
  4480.       free(name2);
  4481.       return(ret);
  4482.     }
  4483.  
  4484.   /* try with all uppercase */
  4485.   strupper(name2);
  4486.   ret = sys_gethostbyname(name2);
  4487.   if (ret != NULL)
  4488.     {
  4489.       free(name2);
  4490.       return(ret);
  4491.     }
  4492.   
  4493.   /* nothing works :-( */
  4494.   free(name2);
  4495.   return(NULL);
  4496. }
  4497.  
  4498.  
  4499. /****************************************************************************
  4500. check if a process exists. Does this work on all unixes?
  4501. ****************************************************************************/
  4502. BOOL process_exists(int pid)
  4503. {
  4504.     return(kill(pid,0) == 0 || errno != ESRCH);
  4505. }
  4506.  
  4507.  
  4508. /*******************************************************************
  4509. turn a uid into a user name
  4510. ********************************************************************/
  4511. char *uidtoname(int uid)
  4512. {
  4513.   static char name[40];
  4514.   struct passwd *pass = getpwuid(uid);
  4515.   if (pass) return(pass->pw_name);
  4516.   slprintf(name,sizeof(name)-1,"%d",uid);
  4517.   return(name);
  4518. }
  4519.  
  4520. /*******************************************************************
  4521. turn a gid into a group name
  4522. ********************************************************************/
  4523. char *gidtoname(int gid)
  4524. {
  4525.   static char name[40];
  4526.   struct group *grp = getgrgid(gid);
  4527.   if (grp) return(grp->gr_name);
  4528.   slprintf(name,sizeof(name)-1,"%d",gid);
  4529.   return(name);
  4530. }
  4531.  
  4532. /*******************************************************************
  4533. block sigs
  4534. ********************************************************************/
  4535. void BlockSignals(BOOL block,int signum)
  4536. {
  4537. #ifdef USE_SIGBLOCK
  4538.   int block_mask = sigmask(signum);
  4539.   static int oldmask = 0;
  4540.   if (block) 
  4541.     oldmask = sigblock(block_mask);
  4542.   else
  4543.     sigsetmask(oldmask);
  4544. #elif defined(USE_SIGPROCMASK)
  4545.   sigset_t set;
  4546.   sigemptyset(&set);
  4547.   sigaddset(&set,signum);
  4548.   sigprocmask(block?SIG_BLOCK:SIG_UNBLOCK,&set,NULL);
  4549. #endif
  4550. }
  4551.  
  4552. #if AJT
  4553. /*******************************************************************
  4554. my own panic function - not suitable for general use
  4555. ********************************************************************/
  4556. void ajt_panic(void)
  4557. {
  4558.   system("/usr/bin/X11/xedit -display solen:0 /tmp/ERROR_FAULT");
  4559. }
  4560. #endif
  4561.  
  4562. #ifdef USE_DIRECT
  4563. #define DIRECT direct
  4564. #else
  4565. #define DIRECT dirent
  4566. #endif
  4567.  
  4568. /*******************************************************************
  4569. a readdir wrapper which just returns the file name
  4570. also return the inode number if requested
  4571. ********************************************************************/
  4572. char *readdirname(void *p)
  4573. {
  4574.   struct DIRECT *ptr;
  4575.   char *dname;
  4576.  
  4577.   if (!p) return(NULL);
  4578.   
  4579.   ptr = (struct DIRECT *)readdir(p);
  4580.   if (!ptr) return(NULL);
  4581.  
  4582.   dname = ptr->d_name;
  4583.  
  4584. #ifdef NEXT2
  4585.   if (telldir(p) < 0) return(NULL);
  4586. #endif
  4587.  
  4588. #ifdef SUNOS5
  4589.   /* this handles a broken compiler setup, causing a mixture
  4590.    of BSD and SYSV headers and libraries */
  4591.   {
  4592.     static BOOL broken_readdir = False;
  4593.     if (!broken_readdir && !(*(dname)) && strequal("..",dname-2))
  4594.       {
  4595.     DEBUG(0,("Your readdir() is broken. You have somehow mixed SYSV and BSD headers and libraries\n"));
  4596.     broken_readdir = True;
  4597.       }
  4598.     if (broken_readdir)
  4599.       dname = dname - 2;
  4600.   }
  4601. #endif
  4602.  
  4603.   {
  4604.     static pstring buf;
  4605.     pstrcpy(buf, dname);
  4606.     unix_to_dos(buf, True);
  4607.     dname = buf;
  4608.   }
  4609.  
  4610.   return(dname);
  4611. }
  4612.  
  4613. /*******************************************************************
  4614.  Utility function used to decide if the last component 
  4615.  of a path matches a (possibly wildcarded) entry in a namelist.
  4616. ********************************************************************/
  4617.  
  4618. BOOL is_in_path(char *name, name_compare_entry *namelist)
  4619. {
  4620.   pstring last_component;
  4621.   char *p;
  4622.  
  4623.   DEBUG(8, ("is_in_path: %s\n", name));
  4624.  
  4625.   /* if we have no list it's obviously not in the path */
  4626.   if((namelist == NULL ) || ((namelist != NULL) && (namelist[0].name == NULL))) 
  4627.   {
  4628.     DEBUG(8,("is_in_path: no name list.\n"));
  4629.     return False;
  4630.   }
  4631.  
  4632.   /* Get the last component of the unix name. */
  4633.   p = strrchr(name, '/');
  4634.   strncpy(last_component, p ? ++p : name, sizeof(last_component)-1);
  4635.   last_component[sizeof(last_component)-1] = '\0'; 
  4636.  
  4637.   for(; namelist->name != NULL; namelist++)
  4638.   {
  4639.     if(namelist->is_wild)
  4640.     {
  4641.       /*
  4642.        * Look for a wildcard match. Use the old
  4643.        * 'unix style' mask match, rather than the
  4644.        * new NT one.
  4645.        */
  4646.       if (unix_mask_match(last_component, namelist->name, case_sensitive, False))
  4647.       {
  4648.          DEBUG(8,("is_in_path: unix_mask_match succeeded\n"));
  4649.          return True;
  4650.       }
  4651.     }
  4652.     else
  4653.     {
  4654.       if((case_sensitive && (strcmp(last_component, namelist->name) == 0))||
  4655.        (!case_sensitive && (StrCaseCmp(last_component, namelist->name) == 0)))
  4656.         {
  4657.          DEBUG(8,("is_in_path: match succeeded\n"));
  4658.          return True;
  4659.         }
  4660.     }
  4661.   }
  4662.   DEBUG(8,("is_in_path: match not found\n"));
  4663.  
  4664.   return False;
  4665. }
  4666.  
  4667. /*******************************************************************
  4668.  Strip a '/' separated list into an array of 
  4669.  name_compare_enties structures suitable for 
  4670.  passing to is_in_path(). We do this for
  4671.  speed so we can pre-parse all the names in the list 
  4672.  and don't do it for each call to is_in_path().
  4673.  namelist is modified here and is assumed to be 
  4674.  a copy owned by the caller.
  4675.  We also check if the entry contains a wildcard to
  4676.  remove a potentially expensive call to mask_match
  4677.  if possible.
  4678. ********************************************************************/
  4679.  
  4680. void set_namearray(name_compare_entry **ppname_array, char *namelist)
  4681. {
  4682.   char *name_end;
  4683.   char *nameptr = namelist;
  4684.   int num_entries = 0;
  4685.   int i;
  4686.  
  4687.   (*ppname_array) = NULL;
  4688.  
  4689.   if((nameptr == NULL ) || ((nameptr != NULL) && (*nameptr == '\0'))) 
  4690.     return;
  4691.  
  4692.   /* We need to make two passes over the string. The
  4693.      first to count the number of elements, the second
  4694.      to split it.
  4695.    */
  4696.   while(*nameptr) 
  4697.     {
  4698.       if ( *nameptr == '/' ) 
  4699.         {
  4700.           /* cope with multiple (useless) /s) */
  4701.           nameptr++;
  4702.           continue;
  4703.         }
  4704.       /* find the next / */
  4705.       name_end = strchr(nameptr, '/');
  4706.  
  4707.       /* oops - the last check for a / didn't find one. */
  4708.       if (name_end == NULL)
  4709.         break;
  4710.  
  4711.       /* next segment please */
  4712.       nameptr = name_end + 1;
  4713.       num_entries++;
  4714.     }
  4715.  
  4716.   if(num_entries == 0)
  4717.     return;
  4718.  
  4719.   if(( (*ppname_array) = (name_compare_entry *)malloc( 
  4720.            (num_entries + 1) * sizeof(name_compare_entry))) == NULL)
  4721.         {
  4722.     DEBUG(0,("set_namearray: malloc fail\n"));
  4723.     return;
  4724.         }
  4725.  
  4726.   /* Now copy out the names */
  4727.   nameptr = namelist;
  4728.   i = 0;
  4729.   while(*nameptr)
  4730.              {
  4731.       if ( *nameptr == '/' ) 
  4732.       {
  4733.           /* cope with multiple (useless) /s) */
  4734.           nameptr++;
  4735.           continue;
  4736.       }
  4737.       /* find the next / */
  4738.       if ((name_end = strchr(nameptr, '/')) != NULL) 
  4739.       {
  4740.           *name_end = 0;
  4741.          }
  4742.  
  4743.       /* oops - the last check for a / didn't find one. */
  4744.       if(name_end == NULL) 
  4745.         break;
  4746.  
  4747.       (*ppname_array)[i].is_wild = ((strchr( nameptr, '?')!=NULL) ||
  4748.                                 (strchr( nameptr, '*')!=NULL));
  4749.       if(((*ppname_array)[i].name = strdup(nameptr)) == NULL)
  4750.       {
  4751.         DEBUG(0,("set_namearray: malloc fail (1)\n"));
  4752.         return;
  4753.       }
  4754.  
  4755.       /* next segment please */
  4756.       nameptr = name_end + 1;
  4757.       i++;
  4758.     }
  4759.   
  4760.   (*ppname_array)[i].name = NULL;
  4761.  
  4762.   return;
  4763. }
  4764.  
  4765. /****************************************************************************
  4766. routine to free a namearray.
  4767. ****************************************************************************/
  4768.  
  4769. void free_namearray(name_compare_entry *name_array)
  4770. {
  4771.   if(name_array == 0)
  4772.     return;
  4773.  
  4774.   if(name_array->name != NULL)
  4775.     free(name_array->name);
  4776.  
  4777.   free((char *)name_array);
  4778. }
  4779.  
  4780. /****************************************************************************
  4781. routine to do file locking
  4782. ****************************************************************************/
  4783. BOOL fcntl_lock(int fd,int op,uint32 offset,uint32 count,int type)
  4784. {
  4785. #if HAVE_FCNTL_LOCK
  4786.   struct flock lock;
  4787.   int ret;
  4788.  
  4789.   if(lp_ole_locking_compat()) {
  4790.     uint32 mask = 0xC0000000;
  4791.  
  4792.     /* make sure the count is reasonable, we might kill the lockd otherwise */
  4793.     count &= ~mask;
  4794.  
  4795.     /* the offset is often strange - remove 2 of its bits if either of
  4796.        the top two bits are set. Shift the top ones by two bits. This
  4797.        still allows OLE2 apps to operate, but should stop lockd from
  4798.        dieing */
  4799.     if ((offset & mask) != 0)
  4800.       offset = (offset & ~mask) | ((offset & mask) >> 2);
  4801.   } else {
  4802.     uint32 mask = ((unsigned)1<<31);
  4803.     int32 s_count = (int32) count; /* Signed count. */
  4804.     int32 s_offset = (int32)offset; /* Signed offset. */
  4805.  
  4806.     /* interpret negative counts as large numbers */
  4807.     if (s_count < 0)
  4808.       s_count &= ~mask;
  4809.  
  4810.     /* no negative offsets */
  4811.     if(s_offset < 0)
  4812.       s_offset &= ~mask;
  4813.  
  4814.     /* count + offset must be in range */
  4815.     while ((s_offset < 0 || (s_offset + s_count < 0)) && mask)
  4816.     {
  4817.       s_offset &= ~mask;
  4818.       mask = mask >> 1;
  4819.     }
  4820.  
  4821.     offset = (uint32)s_offset;
  4822.     count = (uint32)s_count;
  4823.   }
  4824.  
  4825.   DEBUG(8,("fcntl_lock %d %d %d %d %d\n",fd,op,(int)offset,(int)count,type));
  4826.  
  4827.   lock.l_type = type;
  4828.   lock.l_whence = SEEK_SET;
  4829.   lock.l_start = (int)offset;
  4830.   lock.l_len = (int)count;
  4831.   lock.l_pid = 0;
  4832.  
  4833.   errno = 0;
  4834.  
  4835.   ret = fcntl(fd,op,&lock);
  4836.  
  4837.   if (errno != 0)
  4838.     DEBUG(3,("fcntl lock gave errno %d (%s)\n",errno,strerror(errno)));
  4839.  
  4840.   /* a lock query */
  4841.   if (op == F_GETLK) {
  4842.     if ((ret != -1) &&
  4843.         (lock.l_type != F_UNLCK) && 
  4844.         (lock.l_pid != 0) && 
  4845.         (lock.l_pid != getpid())) {
  4846.       DEBUG(3,("fd %d is locked by pid %d\n",fd,lock.l_pid));
  4847.       return(True);
  4848.     }
  4849.  
  4850.     /* it must be not locked or locked by me */
  4851.     return(False);
  4852.   }
  4853.  
  4854.   /* a lock set or unset */
  4855.   if (ret == -1) {
  4856.     DEBUG(3,("lock failed at offset %d count %d op %d type %d (%s)\n",
  4857.             offset,count,op,type,strerror(errno)));
  4858.  
  4859.     /* perhaps it doesn't support this sort of locking?? */
  4860.     if (errno == EINVAL) {
  4861.       DEBUG(3,("locking not supported? returning True\n"));
  4862.       return(True);
  4863.     }
  4864.  
  4865.     return(False);
  4866.   }
  4867.  
  4868.   /* everything went OK */
  4869.   DEBUG(8,("Lock call successful\n"));
  4870.  
  4871.   return(True);
  4872. #else
  4873.   return(False);
  4874. #endif
  4875. }
  4876.  
  4877. /*******************************************************************
  4878. lock a file - returning a open file descriptor or -1 on failure
  4879. The timeout is in seconds. 0 means no timeout
  4880. ********************************************************************/
  4881. int file_lock(char *name,int timeout)
  4882. {  
  4883.   int fd = open(name,O_RDWR|O_CREAT,0666);
  4884.   time_t t=0;
  4885.   if (fd < 0) return(-1);
  4886.  
  4887. #if HAVE_FCNTL_LOCK
  4888.   if (timeout) t = time(NULL);
  4889.   while (!timeout || (time(NULL)-t < timeout)) {
  4890.     if (fcntl_lock(fd,F_SETLK,0,1,F_WRLCK)) return(fd);    
  4891.     msleep(LOCK_RETRY_TIMEOUT);
  4892.   }
  4893.   return(-1);
  4894. #else
  4895.   return(fd);
  4896. #endif
  4897. }
  4898.  
  4899. /*******************************************************************
  4900. unlock a file locked by file_lock
  4901. ********************************************************************/
  4902. void file_unlock(int fd)
  4903. {
  4904.   if (fd<0) return;
  4905. #if HAVE_FCNTL_LOCK
  4906.   fcntl_lock(fd,F_SETLK,0,1,F_UNLCK);
  4907. #endif
  4908.   close(fd);
  4909. }
  4910.  
  4911. /*******************************************************************
  4912. is the name specified one of my netbios names
  4913. returns true is it is equal, false otherwise
  4914. ********************************************************************/
  4915. BOOL is_myname(char *s)
  4916. {
  4917.   int n;
  4918.   BOOL ret = False;
  4919.  
  4920.   for (n=0; my_netbios_names[n]; n++) {
  4921.     if (strequal(my_netbios_names[n], s))
  4922.       ret=True;
  4923.   }
  4924.   DEBUG(8, ("is_myname(\"%s\") returns %d\n", s, ret));
  4925.   return(ret);
  4926. }
  4927.  
  4928. /*******************************************************************
  4929. set the horrid remote_arch string based on an enum.
  4930. ********************************************************************/
  4931. void set_remote_arch(enum remote_arch_types type)
  4932. {
  4933.   ra_type = type;
  4934.   switch( type )
  4935.   {
  4936.   case RA_WFWG:
  4937.     fstrcpy(remote_arch, "WfWg");
  4938.     return;
  4939.   case RA_OS2:
  4940.     fstrcpy(remote_arch, "OS2");
  4941.     return;
  4942.   case RA_WIN95:
  4943.     fstrcpy(remote_arch, "Win95");
  4944.     return;
  4945.   case RA_WINNT:
  4946.     fstrcpy(remote_arch, "WinNT");
  4947.     return;
  4948.   case RA_SAMBA:
  4949.     fstrcpy(remote_arch,"Samba");
  4950.     return;
  4951.   default:
  4952.     ra_type = RA_UNKNOWN;
  4953.     fstrcpy(remote_arch, "UNKNOWN");
  4954.     break;
  4955.   }
  4956. }
  4957.  
  4958. /*******************************************************************
  4959.  Get the remote_arch type.
  4960. ********************************************************************/
  4961. enum remote_arch_types get_remote_arch(void)
  4962. {
  4963.   return ra_type;
  4964. }
  4965.  
  4966.  
  4967. /*******************************************************************
  4968. skip past some unicode strings in a buffer
  4969. ********************************************************************/
  4970. char *skip_unicode_string(char *buf,int n)
  4971. {
  4972.   while (n--)
  4973.   {
  4974.     while (*buf)
  4975.       buf += 2;
  4976.     buf += 2;
  4977.   }
  4978.   return(buf);
  4979. }
  4980.  
  4981. /*******************************************************************
  4982. Return a ascii version of a unicode string
  4983. Hack alert: uses fixed buffer(s) and only handles ascii strings
  4984. ********************************************************************/
  4985. #define MAXUNI 1024
  4986. char *unistrn2(uint16 *buf, int len)
  4987. {
  4988.     static char lbufs[8][MAXUNI];
  4989.     static int nexti;
  4990.     char *lbuf = lbufs[nexti];
  4991.     char *p;
  4992.  
  4993.     nexti = (nexti+1)%8;
  4994.  
  4995.     DEBUG(10, ("unistrn2: "));
  4996.  
  4997.     for (p = lbuf; *buf && p-lbuf < MAXUNI-2 && len > 0; len--, p++, buf++)
  4998.     {
  4999.         DEBUG(10, ("%4x ", *buf));
  5000.         *p = *buf;
  5001.     }
  5002.  
  5003.     DEBUG(10,("\n"));
  5004.  
  5005.     *p = 0;
  5006.     return lbuf;
  5007. }
  5008.  
  5009. /*******************************************************************
  5010. Return a ascii version of a unicode string
  5011. Hack alert: uses fixed buffer(s) and only handles ascii strings
  5012. ********************************************************************/
  5013. #define MAXUNI 1024
  5014. char *unistr2(uint16 *buf)
  5015. {
  5016.     static char lbufs[8][MAXUNI];
  5017.     static int nexti;
  5018.     char *lbuf = lbufs[nexti];
  5019.     char *p;
  5020.  
  5021.     nexti = (nexti+1)%8;
  5022.  
  5023.     DEBUG(10, ("unistr2: "));
  5024.  
  5025.     for (p = lbuf; *buf && p-lbuf < MAXUNI-2; p++, buf++)
  5026.     {
  5027.         DEBUG(10, ("%4x ", *buf));
  5028.         *p = *buf;
  5029.     }
  5030.  
  5031.     DEBUG(10,("\n"));
  5032.  
  5033.     *p = 0;
  5034.     return lbuf;
  5035. }
  5036.  
  5037. /*******************************************************************
  5038. create a null-terminated unicode string from a null-terminated ascii string.
  5039. return number of unicode chars copied, excluding the null character.
  5040.  
  5041. only handles ascii strings
  5042. ********************************************************************/
  5043. #define MAXUNI 1024
  5044. int struni2(uint16 *p, char *buf)
  5045. {
  5046.     int len = 0;
  5047.  
  5048.     if (p == NULL) return 0;
  5049.  
  5050.     DEBUG(10, ("struni2: "));
  5051.  
  5052.     if (buf != NULL)
  5053.     {
  5054.         for (; *buf && len < MAXUNI-2; len++, p++, buf++)
  5055.         {
  5056.             DEBUG(10, ("%2x ", *buf));
  5057.             *p = *buf;
  5058.         }
  5059.  
  5060.         DEBUG(10,("\n"));
  5061.     }
  5062.  
  5063.     *p = 0;
  5064.  
  5065.     return len;
  5066. }
  5067.  
  5068. /*******************************************************************
  5069. Return a ascii version of a unicode string
  5070. Hack alert: uses fixed buffer(s) and only handles ascii strings
  5071. ********************************************************************/
  5072. #define MAXUNI 1024
  5073. char *unistr(char *buf)
  5074. {
  5075.     static char lbufs[8][MAXUNI];
  5076.     static int nexti;
  5077.     char *lbuf = lbufs[nexti];
  5078.     char *p;
  5079.  
  5080.     nexti = (nexti+1)%8;
  5081.  
  5082.     for (p = lbuf; *buf && p-lbuf < MAXUNI-2; p++, buf += 2)
  5083.     {
  5084.         *p = *buf;
  5085.     }
  5086.     *p = 0;
  5087.     return lbuf;
  5088. }
  5089.  
  5090. /*******************************************************************
  5091. strncpy for unicode strings
  5092. ********************************************************************/
  5093. int unistrncpy(char *dst, char *src, int len)
  5094. {
  5095.     int num_wchars = 0;
  5096.  
  5097.     while (*src && len > 0)
  5098.     {
  5099.         *dst++ = *src++;
  5100.         *dst++ = *src++;
  5101.         len--;
  5102.         num_wchars++;
  5103.     }
  5104.     *dst++ = 0;
  5105.     *dst++ = 0;
  5106.  
  5107.     return num_wchars;
  5108. }
  5109.  
  5110.  
  5111. /*******************************************************************
  5112. strcpy for unicode strings.  returns length (in num of wide chars)
  5113. ********************************************************************/
  5114. int unistrcpy(char *dst, char *src)
  5115. {
  5116.     int num_wchars = 0;
  5117.  
  5118.     while (*src)
  5119.     {
  5120.         *dst++ = *src++;
  5121.         *dst++ = *src++;
  5122.         num_wchars++;
  5123.     }
  5124.     *dst++ = 0;
  5125.     *dst++ = 0;
  5126.  
  5127.     return num_wchars;
  5128. }
  5129.  
  5130. /*******************************************************************
  5131. safe string copy into a known length string. maxlength does not
  5132. include the terminating zero.
  5133. ********************************************************************/
  5134. char *safe_strcpy(char *dest, char *src, int maxlength)
  5135. {
  5136.     int len;
  5137.  
  5138.     if (!dest) {
  5139.         DEBUG(0,("ERROR: NULL dest in safe_strcpy\n"));
  5140.         return NULL;
  5141.     }
  5142.  
  5143.     if (!src) {
  5144.         *dest = 0;
  5145.         return dest;
  5146.     } 
  5147.  
  5148.     len = strlen(src);
  5149.  
  5150.     if (len > maxlength) {
  5151.             DEBUG(0,("ERROR: string overflow by %d in safe_strcpy [%.50s]\n",
  5152.                      len-maxlength, src));
  5153.             len = maxlength;
  5154.     }
  5155.  
  5156.     memcpy(dest, src, len);
  5157.     dest[len] = 0;
  5158.     return dest;
  5159.  
  5160. /*******************************************************************
  5161. safe string cat into a string. maxlength does not
  5162. include the terminating zero.
  5163. ********************************************************************/
  5164. char *safe_strcat(char *dest, char *src, int maxlength)
  5165. {
  5166.     int src_len, dest_len;
  5167.  
  5168.     if (!dest) {
  5169.         DEBUG(0,("ERROR: NULL dest in safe_strcat\n"));
  5170.         return NULL;
  5171.     }
  5172.  
  5173.     if (!src) {
  5174.         return dest;
  5175.     }
  5176.  
  5177.     src_len = strlen(src);
  5178.     dest_len = strlen(dest);
  5179.  
  5180.     if (src_len + dest_len > maxlength) {
  5181.             DEBUG(0,("ERROR: string overflow by %d in safe_strcat [%.50s]\n",
  5182.                      src_len + dest_len - maxlength, src));
  5183.             src_len = maxlength - dest_len;
  5184.     }
  5185.  
  5186.     memcpy(&dest[dest_len], src, src_len);
  5187.     dest[dest_len + src_len] = 0;
  5188.     return dest;
  5189. }
  5190.  
  5191.  
  5192. /*******************************************************************
  5193. align a pointer to a multiple of 4 bytes
  5194. ********************************************************************/
  5195. char *align4(char *q, char *base)
  5196. {
  5197.     if ((q - base) & 3)
  5198.     {
  5199.         q += 4 - ((q - base) & 3);
  5200.     }
  5201.     return q;
  5202. }
  5203.  
  5204. /*******************************************************************
  5205. align a pointer to a multiple of 2 bytes
  5206. ********************************************************************/
  5207. char *align2(char *q, char *base)
  5208. {
  5209.     if ((q - base) & 1)
  5210.     {
  5211.         q++;
  5212.     }
  5213.     return q;
  5214. }
  5215.  
  5216. /*******************************************************************
  5217. align a pointer to a multiple of align_offset bytes.  looks like it
  5218. will work for offsets of 0, 2 and 4...
  5219. ********************************************************************/
  5220. char *align_offset(char *q, char *base, int align_offset_len)
  5221. {
  5222.     int mod = ((q - base) & (align_offset_len-1));
  5223.     if (align_offset_len != 0 && mod != 0)
  5224.     {
  5225.         q += align_offset_len - mod;
  5226.     }
  5227.     return q;
  5228. }
  5229.  
  5230. void print_asc(int level, unsigned char *buf,int len)
  5231. {
  5232.     int i;
  5233.     for (i=0;i<len;i++)
  5234.         DEBUG(level,("%c", isprint(buf[i])?buf[i]:'.'));
  5235. }
  5236.  
  5237. void dump_data(int level,char *buf1,int len)
  5238. {
  5239.   unsigned char *buf = (unsigned char *)buf1;
  5240.   int i=0;
  5241.   if (len<=0) return;
  5242.  
  5243.   DEBUG(level,("[%03X] ",i));
  5244.   for (i=0;i<len;) {
  5245.     DEBUG(level,("%02X ",(int)buf[i]));
  5246.     i++;
  5247.     if (i%8 == 0) DEBUG(level,(" "));
  5248.     if (i%16 == 0) {      
  5249.       print_asc(level,&buf[i-16],8); DEBUG(level,(" "));
  5250.       print_asc(level,&buf[i-8],8); DEBUG(level,("\n"));
  5251.       if (i<len) DEBUG(level,("[%03X] ",i));
  5252.     }
  5253.   }
  5254.   if (i%16) {
  5255.     int n;
  5256.  
  5257.     n = 16 - (i%16);
  5258.     DEBUG(level,(" "));
  5259.     if (n>8) DEBUG(level,(" "));
  5260.     while (n--) DEBUG(level,("   "));
  5261.  
  5262.     n = MIN(8,i%16);
  5263.     print_asc(level,&buf[i-(i%16)],n); DEBUG(level,(" "));
  5264.     n = (i%16) - n;
  5265.     if (n>0) print_asc(level,&buf[i-n],n); 
  5266.     DEBUG(level,("\n"));    
  5267.   }
  5268. }
  5269.  
  5270. char *tab_depth(int depth)
  5271. {
  5272.     static pstring spaces;
  5273.     memset(spaces, ' ', depth * 4);
  5274.     spaces[depth * 4] = 0;
  5275.     return spaces;
  5276. }
  5277.  
  5278.  
  5279.